diff --git a/android.py b/android.py
index bdd893d..f3a8fd3 100644
--- a/android.py
+++ b/android.py
@@ -15,14 +15,42 @@
 
 """
 JSON RPC interface to android scripting engine.
+
+Example:
+    a = Android()
+    a.makeToast("poptart")
+    a.close()
+
+Also supports serializing data objects (class instances). Register them with the android client object.
+
+
+class Mydata:
+    def __init__(self, value):
+        self.value = value
+
+a = Android()
+a.register(Mydata)
+
+data = Mydata(2)
+a.makeCall(data)
+a.close()
+
+This feature requires support on the SL4A side for the Jackson ObjectMapper.
+
+http://jackson.codehaus.org/1.7.3/javadoc/org/codehaus/jackson/map/ObjectMapper.html
+
+Where you also need a POJO on the server side. Otherwise this feature cannot be used.
 """
 
 __author__ = 'Keith Dart <dart@google.com>'
 __oldauthor__ = 'Damon Kohler <damonkohler@gmail.com>'
 
 import os
-import json
+import sys
 import socket
+import logging
+from json.decoder import JSONDecoder
+from json.encoder import JSONEncoder
 
 
 HOST = os.environ.get('AP_HOST', None)
@@ -42,6 +70,69 @@
     """Raised when there is some error in exchanging data with server on device."""
 
 
+class AndroidJSONDecoder(JSONDecoder):
+    def __init__(self):
+        super().__init__(object_hook=self._decode_object, parse_float=None, parse_int=None,
+                parse_constant=None, strict=True, object_pairs_hook=None)
+        self._regs = {}
+
+    def _decode_object(self, d):
+        if "@class" in d:
+            cname = d.pop("@class")
+            cls = _load_class(cname)
+            o = cls.__new__(cls)
+            while d:
+                k, v = d.popitem()
+                setattr(o, k, v)
+            return o
+        else:
+            return d
+
+    def register(self, cls, decoder=None):
+        self._regs[cls] = decoder
+
+    def decode(self, s):
+        return super().decode(str(s, encoding="utf8"))
+
+
+def _load_class(path):
+    modname, clsname = path.rsplit(".", 1)
+    try:
+        mod = sys.modules[modname]
+    except KeyError:
+        pass
+    __import__(modname)
+    mod = sys.modules[modname]
+    return getattr(mod, clsname)
+
+
+class AndroidJSONEncoder(JSONEncoder):
+    def __init__(self):
+        super().__init__ (skipkeys=False, ensure_ascii=False,
+                check_circular=True, allow_nan=True, sort_keys=False,
+                indent=None, separators=None, default=None)
+        self._regs = {}
+
+    def default(self, o):
+        try:
+            encoder = self._regs[type(o)]
+        except KeyError:
+            return super().default(o)
+        if encoder is not None:
+            return encoder(o)
+        d = o.__dict__.copy()
+        t = type(o)
+        d["@class"] = "{}.{}".format(t.__module__, t.__name__)
+        return d
+
+    def encode(self, o):
+        s = super().encode(o)
+        return s.encode("utf8")+b'\n'
+
+    def register(self, cls, encoder=None):
+        self._regs[cls] = encoder
+
+
 def IDCounter():
     i = 0
     while True:
@@ -49,20 +140,30 @@
         i += 1
 
 class Android(object):
+    """Client interface to SL4A server running on Android.
+
+    Supports generic calling to SL4A APIs by getting an API method as an attribute.
+
+    Example:
+        a = Android()
+        a.makeToast("poptart")
+    """
     COUNTER = IDCounter()
 
     def __init__(self, cmd='initiate', uid=-1, port=PORT, addr=HOST):
         self.client = None # prevent close errors on connect failure
         self.uid = None
+        self._encoder = AndroidJSONEncoder()
+        self._decoder = AndroidJSONDecoder()
         conn = socket.create_connection((addr, port))
         self.client = conn.makefile(mode="brw")
         handshake = {'cmd':cmd, 'uid':uid}
-        self.client.write(json.dumps(handshake).encode("utf8")+b'\n')
+        self.client.write(self._encoder.encode(handshake))
         self.client.flush()
-        resp = self.client.readline()
+        resp = self.client.readline(16384)
         if not resp:
             raise SL4AProtocolError("No response from handshake.")
-        result = json.loads(str(resp, encoding="utf8"))
+        result = self._decoder.decode(resp)
         if result['status']:
           self.uid = result['uid']
         else:
@@ -70,24 +171,41 @@
 
     def close(self):
         if self.client is not None:
-            self.client.close()
+            c = self.client
             self.client = None
+            try:
+                # TODO gracefully terminate session when supported on server side.
+                # e.g.: c.write(self._encoder.encode({"cmd":"terminate", "uid":self.uid}))
+                c.close()
+            except (ValueError, OSError):
+                logging.warn("Closing Android interface that was already closed.")
 
     def __del__(self):
         self.close()
 
+    def register(self, cls, encoder=None, decoder=None):
+        """Register a class object that will support serialization to and
+        from sl4a server.
+
+        Different encoder and decoder callables may be supplied. If not
+        supplied, generic ones will be used.
+
+        A factory function can register objects as server side POJOs are developed.
+        """
+        self._encoder.register(cls, encoder)
+        self._decoder.register(cls, decoder)
+
     def _rpc(self, method, *args):
         apiid = next(Android.COUNTER)
         data = {'id': apiid,
                     'method': method,
                     'params': args}
-        request = json.dumps(data)
-        self.client.write(request.encode("utf8")+b'\n')
+        self.client.write(self._encoder.encode(data))
         self.client.flush()
-        response = self.client.readline()
+        response = self.client.readline(16384)
         if not response:
             raise SL4AProtocolError("No response from server.")
-        result = json.loads(str(response, encoding="utf8"))
+        result = self._decoder.decode(response)
         if result['error']:
             raise SL4AAPIError(result['error'])
         if result['id'] != apiid:
@@ -176,6 +294,4 @@
 
 # Run as top-level script for handy test utility
 if __name__ == "__main__":
-    import sys
     android(sys.argv)
-
diff --git a/test_android.py b/test_android.py
new file mode 100644
index 0000000..6bad0cc
--- /dev/null
+++ b/test_android.py
@@ -0,0 +1,45 @@
+#!/usr/bin/python3.4
+# vim:ts=4:sw=4:softtabstop=4:smarttab:expandtab
+
+#   Copyright 2014- Google, Inc.
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+"""
+Unit tests for sl4a client module.
+"""
+
+
+import unittest
+
+import android
+
+class TestClass:
+    def __init__(self, v):
+        self._v = v
+
+class AndroidTests(unittest.TestCase):
+
+    def test_object_codec(self):
+        i = TestClass(1)
+        encoder = android.AndroidJSONEncoder()
+        encoder.register(TestClass)
+        j = encoder.encode(i)
+        decoder = android.AndroidJSONDecoder()
+        o = decoder.decode(j)
+        self.assertTrue(type(o) is type(i))
+
+
+
+if __name__ == "__main__":
+    unittest.main()