Simplify the serialization / deserializtion methods (CommonSerializeUtils)

14 files changed, 500 insertions, 542 deletions

diff --git a/java/android/OlmLibSdk/olm-sdk/src/androidTest/java/org/matrix/olm/OlmSessionTest.java b/java/android/OlmLibSdk/olm-sdk/src/androidTest/java/org/matrix/olm/OlmSessionTest.java
index 6c888d0..675d72c 100644
--- a/java/android/OlmLibSdk/olm-sdk/src/androidTest/java/org/matrix/olm/OlmSessionTest.java
+++ b/java/android/OlmLibSdk/olm-sdk/src/androidTest/java/org/matrix/olm/OlmSessionTest.java
@@ -112,7 +112,7 @@ public class OlmSessionTest {
         assertTrue(0!=aliceSession.getOlmSessionId());
 
         // CREATE ALICE OUTBOUND SESSION and encrypt message to bob
-        assertNotNull(aliceSession.initOutboundSessionWithAccount(aliceAccount, bobIdentityKey, bobOneTimeKey));
+        assertNotNull(aliceSession.initOutboundSession(aliceAccount, bobIdentityKey, bobOneTimeKey));
         String clearMsg = "Heloo bob , this is alice!";
         OlmMessage encryptedMsgToBob = aliceSession.encryptMessage(clearMsg);
         assertNotNull(encryptedMsgToBob);
@@ -129,7 +129,7 @@ public class OlmSessionTest {
         assertTrue(0!=bobSession.getOlmSessionId());
 
         try {
-            bobSession.initInboundSessionWithAccount(bobAccount, encryptedMsgToBob.mCipherText);
+            bobSession.initInboundSession(bobAccount, encryptedMsgToBob.mCipherText);
         } catch (Exception e) {
             assertTrue("initInboundSessionWithAccount failed " + e.getMessage(), false);
         }
@@ -211,7 +211,7 @@ public class OlmSessionTest {
         assertTrue(0!=aliceSession.getOlmSessionId());
 
         // CREATE ALICE OUTBOUND SESSION and encrypt message to bob
-        assertNotNull(aliceSession.initOutboundSessionWithAccount(aliceAccount, bobIdentityKey, bobOneTimeKey));
+        assertNotNull(aliceSession.initOutboundSession(aliceAccount, bobIdentityKey, bobOneTimeKey));
         String helloClearMsg = "Hello I'm Alice!";
 
         OlmMessage encryptedAliceToBobMsg1 = aliceSession.encryptMessage(helloClearMsg);
@@ -229,7 +229,7 @@ public class OlmSessionTest {
         assertTrue(0!=bobSession.getOlmSessionId());
 
         try {
-            bobSession.initInboundSessionWithAccount(bobAccount, encryptedAliceToBobMsg1.mCipherText);
+            bobSession.initInboundSession(bobAccount, encryptedAliceToBobMsg1.mCipherText);
         } catch (Exception e) {
             assertTrue("initInboundSessionWithAccount failed " + e.getMessage(), false);
         }
@@ -381,7 +381,7 @@ public class OlmSessionTest {
         String bobOneTimeKey1 = TestHelper.getOneTimeKey(bobOneTimeKeys, 1);
 
         // create alice inbound session for bob
-        assertTrue(0==aliceSession.initOutboundSessionWithAccount(aliceAccount, bobIdentityKey, bobOneTimeKey1));
+        assertTrue(0==aliceSession.initOutboundSession(aliceAccount, bobIdentityKey, bobOneTimeKey1));
 
         String aliceClearMsg = "hello helooo to bob!";
         OlmMessage encryptedAliceToBobMsg1 = aliceSession.encryptMessage(aliceClearMsg);
@@ -389,7 +389,7 @@ public class OlmSessionTest {
 
         // init bob session with alice PRE KEY
         try {
-            bobSession.initInboundSessionWithAccount(bobAccount, encryptedAliceToBobMsg1.mCipherText);
+            bobSession.initInboundSession(bobAccount, encryptedAliceToBobMsg1.mCipherText);
         } catch (Exception e) {
             assertTrue("initInboundSessionWithAccount failed " + e.getMessage(), false);
         }
@@ -463,7 +463,7 @@ public class OlmSessionTest {
         assertTrue(0!=aliceSession.getOlmSessionId());
 
         // CREATE ALICE OUTBOUND SESSION and encrypt message to bob
-        assertNotNull(aliceSession.initOutboundSessionWithAccount(aliceAccount, bobIdentityKey, bobOneTimeKey));
+        assertNotNull(aliceSession.initOutboundSession(aliceAccount, bobIdentityKey, bobOneTimeKey));
         String helloClearMsg = "Hello I'm Alice!";
 
         OlmMessage encryptedAliceToBobMsg1 = aliceSession.encryptMessage(helloClearMsg);
@@ -481,7 +481,7 @@ public class OlmSessionTest {
 
         // init bob session with alice PRE KEY
         try {
-            bobSession.initInboundSessionWithAccount(bobAccount, encryptedAliceToBobMsg1.mCipherText);
+            bobSession.initInboundSession(bobAccount, encryptedAliceToBobMsg1.mCipherText);
         } catch (Exception e) {
             assertTrue("initInboundSessionWithAccount failed " + e.getMessage(), false);
         }
@@ -608,13 +608,13 @@ public class OlmSessionTest {
         }
 
         // SANITY CHECK TESTS FOR: initOutboundSessionWithAccount()
-        assertTrue(-1==aliceSession.initOutboundSessionWithAccount(null, bobIdentityKey, bobOneTimeKey));
-        assertTrue(-1==aliceSession.initOutboundSessionWithAccount(aliceAccount, null, bobOneTimeKey));
-        assertTrue(-1==aliceSession.initOutboundSessionWithAccount(aliceAccount, bobIdentityKey, null));
-        assertTrue(-1==aliceSession.initOutboundSessionWithAccount(null, null, null));
+        assertTrue(-1==aliceSession.initOutboundSession(null, bobIdentityKey, bobOneTimeKey));
+        assertTrue(-1==aliceSession.initOutboundSession(aliceAccount, null, bobOneTimeKey));
+        assertTrue(-1==aliceSession.initOutboundSession(aliceAccount, bobIdentityKey, null));
+        assertTrue(-1==aliceSession.initOutboundSession(null, null, null));
 
         // init properly
-        assertTrue(0==aliceSession.initOutboundSessionWithAccount(aliceAccount, bobIdentityKey, bobOneTimeKey));
+        assertTrue(0==aliceSession.initOutboundSession(aliceAccount, bobIdentityKey, bobOneTimeKey));
 
         // SANITY CHECK TESTS FOR: encryptMessage()
         assertTrue(null==aliceSession.encryptMessage(null));
@@ -629,7 +629,7 @@ public class OlmSessionTest {
             bobSession = new OlmSession();
             String errorMessage = null;
             try {
-                bobSession.initInboundSessionWithAccount(null, encryptedMsgToBob.mCipherText);
+                bobSession.initInboundSession(null, encryptedMsgToBob.mCipherText);
             } catch (Exception e) {
                 errorMessage = e.getMessage();
             }
@@ -638,7 +638,7 @@ public class OlmSessionTest {
 
             errorMessage = null;
             try {
-                bobSession.initInboundSessionWithAccount(bobAccount, null);
+                bobSession.initInboundSession(bobAccount, null);
             } catch (Exception e) {
                 errorMessage = e.getMessage();
             }
@@ -647,7 +647,7 @@ public class OlmSessionTest {
 
             errorMessage = null;
             try {
-                bobSession.initInboundSessionWithAccount(bobAccount, INVALID_PRE_KEY);
+                bobSession.initInboundSession(bobAccount, INVALID_PRE_KEY);
             } catch (Exception e) {
                 errorMessage = e.getMessage();
             }
@@ -657,7 +657,7 @@ public class OlmSessionTest {
             // init properly
             errorMessage = null;
             try {
-                bobSession.initInboundSessionWithAccount(bobAccount, encryptedMsgToBob.mCipherText);
+                bobSession.initInboundSession(bobAccount, encryptedMsgToBob.mCipherText);
             } catch (Exception e) {
                 errorMessage = e.getMessage();
             }
diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/CommonSerializeUtils.java b/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/CommonSerializeUtils.java
index c3f9757..72437e4 100644
--- a/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/CommonSerializeUtils.java
+++ b/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/CommonSerializeUtils.java
@@ -35,7 +35,7 @@ abstract class CommonSerializeUtils {
      * @param aOutStream output stream for serializing
      * @throws IOException exception
      */
-    protected void serializeObject(ObjectOutputStream aOutStream) throws IOException {
+    protected void serialize(ObjectOutputStream aOutStream) throws IOException {
         aOutStream.defaultWriteObject();
 
         // generate serialization key
@@ -43,7 +43,7 @@ abstract class CommonSerializeUtils {
 
         // compute pickle string
         StringBuffer errorMsg = new StringBuffer();
-        String pickledData = serializeDataWithKey(key, errorMsg);
+        String pickledData = serialize(key, errorMsg);
 
         if(null == pickledData) {
             throw new OlmException(OlmException.EXCEPTION_CODE_ACCOUNT_SERIALIZATION, String.valueOf(errorMsg));
@@ -59,33 +59,22 @@ abstract class CommonSerializeUtils {
      * @throws IOException exception
      * @throws ClassNotFoundException exception
      */
-    protected void deserializeObject(ObjectInputStream aInStream) throws IOException, ClassNotFoundException {
+    protected void deserialize(ObjectInputStream aInStream) throws IOException, ClassNotFoundException {
         aInStream.defaultReadObject();
-        StringBuffer errorMsg = new StringBuffer();
 
         String key = (String) aInStream.readObject();
         String pickledData = (String) aInStream.readObject();
 
-        if(TextUtils.isEmpty(key)) {
+        if (TextUtils.isEmpty(key)) {
             throw new OlmException(OlmException.EXCEPTION_CODE_ACCOUNT_DESERIALIZATION, OlmException.EXCEPTION_MSG_INVALID_PARAMS_DESERIALIZATION+" key");
-
-        } else if(TextUtils.isEmpty(pickledData)) {
+        } else if (TextUtils.isEmpty(pickledData)) {
             throw new OlmException(OlmException.EXCEPTION_CODE_ACCOUNT_DESERIALIZATION, OlmException.EXCEPTION_MSG_INVALID_PARAMS_DESERIALIZATION+" pickle");
-
-        } else if(!createNewObjectFromSerialization()) {
-            throw new OlmException(OlmException.EXCEPTION_CODE_ACCOUNT_DESERIALIZATION, OlmException.EXCEPTION_MSG_INIT_NEW_ACCOUNT_DESERIALIZATION);
-
-        } else if(!initWithSerializedData(pickledData, key, errorMsg)) {
-            releaseObjectFromSerialization(); // prevent memory leak
-            throw new OlmException(OlmException.EXCEPTION_CODE_ACCOUNT_DESERIALIZATION, String.valueOf(errorMsg));
-
-        } else {
-            Log.d(LOG_TAG,"## readObject(): success");
         }
+
+        deserialize(pickledData, key);
+        Log.d(LOG_TAG,"## deserializeObject(): success");
     }
 
-    protected abstract String serializeDataWithKey(String aKey, StringBuffer aErrorMsg);
-    protected abstract boolean initWithSerializedData(String aSerializedData, String aKey, StringBuffer aErrorMsg);
-    protected abstract boolean createNewObjectFromSerialization();
-    protected abstract void releaseObjectFromSerialization();
+    protected abstract String serialize(String aKey, StringBuffer aErrorMsg);
+    protected abstract void deserialize(String aSerializedData, String aKey) throws IOException;
 }
diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmAccount.java b/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmAccount.java
index 1e41fa1..649085e 100644
--- a/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmAccount.java
+++ b/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmAccount.java
@@ -69,105 +69,6 @@ public class OlmAccount extends CommonSerializeUtils implements Serializable {
     }
 
     /**
-     * Kick off the serialization mechanism.
-     * @param aOutStream output stream for serializing
-     * @throws IOException exception
-     */
-    private void writeObject(ObjectOutputStream aOutStream) throws IOException {
-        serializeObject(aOutStream);
-    }
-
-    /**
-     * Kick off the deserialization mechanism.
-     * @param aInStream input stream
-     * @throws IOException exception
-     * @throws ClassNotFoundException exception
-     */
-    private void readObject(ObjectInputStream aInStream) throws IOException, ClassNotFoundException {
-        deserializeObject(aInStream);
-    }
-
-    @Override
-    protected boolean createNewObjectFromSerialization() {
-        return createNewAccount();
-    }
-
-    @Override
-    protected void releaseObjectFromSerialization() {
-        releaseAccount();
-    }
-
-    /**
-     * Return an account as a base64 string.<br>
-     * The account is serialized and encrypted with aKey.
-     * In case of failure, an error human readable
-     * description is provide in aErrorMsg.
-     * @param aKey encryption key
-     * @param aErrorMsg error message description
-     * @return pickled base64 string if operation succeed, null otherwise
-     */
-    @Override
-    protected String serializeDataWithKey(String aKey, StringBuffer aErrorMsg) {
-        String pickleRetValue = null;
-
-        // sanity check
-        if(null == aErrorMsg) {
-            Log.e(LOG_TAG,"## serializeDataWithKey(): invalid parameter - aErrorMsg=null");
-        } else if(TextUtils.isEmpty(aKey)) {
-            aErrorMsg.append("Invalid input parameters in serializeDataWithKey()");
-        } else {
-            aErrorMsg.setLength(0);
-            try {
-                pickleRetValue = new String(serializeDataWithKeyJni(aKey.getBytes("UTF-8"), aErrorMsg), "UTF-8");
-            } catch (Exception e) {
-                Log.e(LOG_TAG, "## serializeDataWithKey() failed " + e.getMessage());
-                aErrorMsg.append(e.getMessage());
-            }
-        }
-
-        return pickleRetValue;
-    }
-    private native byte[] serializeDataWithKeyJni(byte[] aKey, StringBuffer aErrorMsg);
-
-
-    /**
-     * Loads an account from a pickled base64 string.<br>
-     * See {@link #serializeDataWithKey(String, StringBuffer)}
-     * @param aSerializedData pickled account in a base64 string format
-     * @param aKey key used to encrypted
-     * @param aErrorMsg error message description
-     * @return true if operation succeed, false otherwise
-     */
-    @Override
-    protected boolean initWithSerializedData(String aSerializedData, String aKey, StringBuffer aErrorMsg) {
-        boolean retCode = false;
-        String jniError;
-
-        if (null == aErrorMsg) {
-            Log.e(LOG_TAG, "## initWithSerializedData(): invalid input error parameter");
-        } else {
-            aErrorMsg.setLength(0);
-
-            try {
-                if (TextUtils.isEmpty(aSerializedData) || TextUtils.isEmpty(aKey)) {
-                    Log.e(LOG_TAG, "## initWithSerializedData(): invalid input parameters");
-                } else if (null == (jniError = initWithSerializedDataJni(aSerializedData.getBytes("UTF-8"), aKey.getBytes("UTF-8")))) {
-                    retCode = true;
-                } else {
-                    aErrorMsg.append(jniError);
-                }
-            } catch (Exception e) {
-                Log.e(LOG_TAG, "## initWithSerializedData() failed " + e.getMessage());
-                aErrorMsg.append(e.getMessage());
-            }
-        }
-
-        return retCode;
-    }
-    
-    private native String initWithSerializedDataJni(byte[] aSerializedDataBuffer, byte[] aKeyBuffer);
-
-    /**
      * Getter on the account ID.
      * @return native account ID
      */
@@ -230,6 +131,14 @@ public class OlmAccount extends CommonSerializeUtils implements Serializable {
     private native long createNewAccountJni();
 
     /**
+     * Return true the object resources have been released.<br>
+     * @return true the object resources have been released
+     */
+    public boolean isReleased() {
+        return (0 == mNativeId);
+    }
+
+    /**
      * Return the identity keys (identity and fingerprint keys) in a dictionary.<br>
      * Public API for {@link #identityKeysJni()}.<br>
      * Ex:<tt>
@@ -394,14 +303,6 @@ public class OlmAccount extends CommonSerializeUtils implements Serializable {
     private native byte[] signMessageJni(byte[] aMessage);
 
     /**
-     * Return true the object resources have been released.<br>
-     * @return true the object resources have been released
-     */
-    public boolean isReleased() {
-        return (0 == mNativeId);
-    }
-
-    /**
      * Build a string-string dictionary from a jsonObject.<br>
      * @param jsonObject the object to parse
      * @return the map
@@ -461,4 +362,95 @@ public class OlmAccount extends CommonSerializeUtils implements Serializable {
 
         return null;
     }
+
+    //==============================================================================================================
+    // Serialization management
+    //==============================================================================================================
+
+    /**
+     * Kick off the serialization mechanism.
+     * @param aOutStream output stream for serializing
+     * @throws IOException exception
+     */
+    private void writeObject(ObjectOutputStream aOutStream) throws IOException {
+        serialize(aOutStream);
+    }
+
+    /**
+     * Kick off the deserialization mechanism.
+     * @param aInStream input stream
+     * @throws IOException exception
+     * @throws ClassNotFoundException exception
+     */
+    private void readObject(ObjectInputStream aInStream) throws IOException, ClassNotFoundException {
+        deserialize(aInStream);
+    }
+
+    /**
+     * Return an account as a base64 string.<br>
+     * The account is serialized and encrypted with aKey.
+     * In case of failure, an error human readable
+     * description is provide in aErrorMsg.
+     * @param aKey encryption key
+     * @param aErrorMsg error message description
+     * @return pickled base64 string if operation succeed, null otherwise
+     */
+    @Override
+    protected String serialize(String aKey, StringBuffer aErrorMsg) {
+        String pickleRetValue = null;
+
+        // sanity check
+        if(null == aErrorMsg) {
+            Log.e(LOG_TAG,"## serialize(): invalid parameter - aErrorMsg=null");
+        } else if(TextUtils.isEmpty(aKey)) {
+            aErrorMsg.append("Invalid input parameters in serializeDataWithKey()");
+        } else {
+            aErrorMsg.setLength(0);
+            try {
+                pickleRetValue = new String(serializeJni(aKey.getBytes("UTF-8"), aErrorMsg), "UTF-8");
+            } catch (Exception e) {
+                Log.e(LOG_TAG, "## serialize() failed " + e.getMessage());
+                aErrorMsg.append(e.getMessage());
+            }
+        }
+
+        return pickleRetValue;
+    }
+
+    private native byte[] serializeJni(byte[] aKey, StringBuffer aErrorMsg);
+
+    /**
+     * Loads an account from a pickled base64 string.<br>
+     * See {@link #serialize(String, StringBuffer)}
+     * @param aSerializedData pickled account in a base64 string format
+     * @param aKey key used to encrypted
+     */
+    @Override
+    protected void deserialize(String aSerializedData, String aKey) throws IOException {
+        if (!createNewAccount()) {
+            throw new OlmException(OlmException.EXCEPTION_CODE_INIT_ACCOUNT_CREATION,OlmException.EXCEPTION_MSG_INIT_ACCOUNT_CREATION);
+        }
+
+        StringBuffer errorMsg = new StringBuffer();
+
+        try {
+            String jniError;
+            if (TextUtils.isEmpty(aSerializedData) || TextUtils.isEmpty(aKey)) {
+                Log.e(LOG_TAG, "## deserialize(): invalid input parameters");
+                errorMsg.append("invalid input parameters");
+            } else if (null != (jniError = deserializeJni(aSerializedData.getBytes("UTF-8"), aKey.getBytes("UTF-8")))) {
+                errorMsg.append(jniError);
+            }
+        } catch (Exception e) {
+            Log.e(LOG_TAG, "## deserialize() failed " + e.getMessage());
+            errorMsg.append(e.getMessage());
+        }
+
+        if (errorMsg.length() > 0) {
+            releaseAccount();
+            throw new OlmException(OlmException.EXCEPTION_CODE_ACCOUNT_DESERIALIZATION, String.valueOf(errorMsg));
+        }
+    }
+
+    private native String deserializeJni(byte[] aSerializedDataBuffer, byte[] aKeyBuffer);
 }
diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmInboundGroupSession.java b/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmInboundGroupSession.java
index bfd50fb..68878c7 100644
--- a/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmInboundGroupSession.java
+++ b/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmInboundGroupSession.java
@@ -65,13 +65,13 @@ public class OlmInboundGroupSession extends CommonSerializeUtils implements Seri
      * Constructor.<br>
      * Create and save a new native session instance ID and start a new inbound group session.
      * The session key parameter is retrieved from an outbound group session
-     * See {@link #createNewSession()} and {@link #initInboundGroupSessionWithSessionKey(String)}
+     * See {@link #createNewSession()} and {@link #initInboundGroupSession(String)}
      * @param aSessionKey session key
      * @throws OlmException constructor failure
      */
     public OlmInboundGroupSession(String aSessionKey) throws OlmException {
         if(createNewSession()) {
-            if (0 != initInboundGroupSessionWithSessionKey(aSessionKey)) {
+            if (0 != initInboundGroupSession(aSessionKey)) {
                 releaseSession();// prevent memory leak before throwing
                 throw new OlmException(OlmException.EXCEPTION_CODE_INIT_INBOUND_GROUP_SESSION,OlmException.EXCEPTION_MSG_INIT_INBOUND_GROUP_SESSION);
             }
@@ -115,29 +115,37 @@ public class OlmInboundGroupSession extends CommonSerializeUtils implements Seri
     private native long createNewSessionJni();
 
     /**
+     * Return true the object resources have been released.<br>
+     * @return true the object resources have been released
+     */
+    public boolean isReleased() {
+        return (0 == mNativeId);
+    }
+
+    /**
      * Start a new inbound group session.<br>
      * The session key parameter is retrieved from an outbound group session
      * see {@link OlmOutboundGroupSession#sessionKey()}
      * @param aSessionKey session key
      * @return 0 if operation succeed, -1 otherwise
      */
-    private int initInboundGroupSessionWithSessionKey(String aSessionKey) {
+    private int initInboundGroupSession(String aSessionKey) {
         int retCode = -1;
 
         if(TextUtils.isEmpty(aSessionKey)){
-            Log.e(LOG_TAG, "## initInboundGroupSessionWithSessionKey(): invalid session key");
+            Log.e(LOG_TAG, "## initInboundGroupSession(): invalid session key");
         } else {
             try {
-                retCode = initInboundGroupSessionWithSessionKeyJni(aSessionKey.getBytes("UTF-8"));
+                retCode = initInboundGroupSessionJni(aSessionKey.getBytes("UTF-8"));
             } catch (Exception e) {
-                Log.e(LOG_TAG, "## initInboundGroupSessionWithSessionKey() failed " + e.getMessage());
+                Log.e(LOG_TAG, "## initInboundGroupSession() failed " + e.getMessage());
             }
         }
 
         return retCode;
     }
-    private native int initInboundGroupSessionWithSessionKeyJni(byte[] aSessionKeyBuffer);
 
+    private native int initInboundGroupSessionJni(byte[] aSessionKeyBuffer);
 
     /**
      * Retrieve the base64-encoded identifier for this inbound group session.
@@ -187,13 +195,17 @@ public class OlmInboundGroupSession extends CommonSerializeUtils implements Seri
 
     private native byte[] decryptMessageJni(byte[] aEncryptedMsg, DecryptMessageResult aDecryptMessageResult, StringBuffer aErrorMsg);
 
+    //==============================================================================================================
+    // Serialization management
+    //==============================================================================================================
+
     /**
      * Kick off the serialization mechanism.
      * @param aOutStream output stream for serializing
      * @throws IOException exception
      */
     private void writeObject(ObjectOutputStream aOutStream) throws IOException {
-        serializeObject(aOutStream);
+        serialize(aOutStream);
     }
 
     /**
@@ -203,17 +215,7 @@ public class OlmInboundGroupSession extends CommonSerializeUtils implements Seri
      * @throws ClassNotFoundException exception
      */
     private void readObject(ObjectInputStream aInStream) throws IOException, ClassNotFoundException {
-        deserializeObject(aInStream);
-    }
-
-    @Override
-    protected boolean createNewObjectFromSerialization() {
-        return createNewSession();
-    }
-
-    @Override
-    protected void releaseObjectFromSerialization() {
-        releaseSession();
+        deserialize(aInStream);
     }
 
     /**
@@ -226,20 +228,20 @@ public class OlmInboundGroupSession extends CommonSerializeUtils implements Seri
      * @return pickled base64 string if operation succeed, null otherwise
      */
     @Override
-    protected String serializeDataWithKey(String aKey, StringBuffer aErrorMsg) {
+    protected String serialize(String aKey, StringBuffer aErrorMsg) {
         String pickleRetValue = null;
 
         // sanity check
         if(null == aErrorMsg) {
-            Log.e(LOG_TAG,"## serializeDataWithKey(): invalid parameter - aErrorMsg=null");
+            Log.e(LOG_TAG,"## serialize(): invalid parameter - aErrorMsg=null");
         } else if(TextUtils.isEmpty(aKey)) {
-            aErrorMsg.append("Invalid input parameters in serializeDataWithKey()");
+            aErrorMsg.append("Invalid input parameters in serialize()");
         } else {
             aErrorMsg.setLength(0);
             try {
-                pickleRetValue = new String(serializeDataWithKeyJni(aKey.getBytes("UTF-8"), aErrorMsg), "UTF-8");
+                pickleRetValue = new String(serializeJni(aKey.getBytes("UTF-8"), aErrorMsg), "UTF-8");
             } catch (Exception e) {
-                Log.e(LOG_TAG, "## serializeDataWithKey() failed " + e.getMessage());
+                Log.e(LOG_TAG, "## serialize() failed " + e.getMessage());
                 aErrorMsg.append(e.getMessage());
             }
         }
@@ -247,60 +249,51 @@ public class OlmInboundGroupSession extends CommonSerializeUtils implements Seri
         return pickleRetValue;
     }
     /**
-     * JNI counter part of {@link #serializeDataWithKey(String, StringBuffer)}.
+     * JNI counter part of {@link #serialize(String, StringBuffer)}.
      * @param aKey encryption key
      * @param aErrorMsg error message description
      * @return pickled base64 string if operation succeed, null otherwise
      */
-    private native byte[] serializeDataWithKeyJni(byte[] aKey, StringBuffer aErrorMsg);
-
+    private native byte[] serializeJni(byte[] aKey, StringBuffer aErrorMsg);
 
     /**
-     * Load an inbound group session from a pickled base64 string.<br>
-     * See {@link #serializeDataWithKey(String, StringBuffer)}
-     * @param aSerializedData pickled inbound group session in a base64 string format
-     * @param aKey encrypting key used in {@link #serializeDataWithKey(String, StringBuffer)}
-     * @param aErrorMsg error message description
-     * @return true if operation succeed, false otherwise
+     * Loads an account from a pickled base64 string.<br>
+     * See {@link #serialize(String, StringBuffer)}
+     * @param aSerializedData pickled account in a base64 string format
+     * @param aKey key used to encrypted
      */
     @Override
-    protected boolean initWithSerializedData(String aSerializedData, String aKey, StringBuffer aErrorMsg) {
-        boolean retCode = false;
-        String jniError;
+    protected void deserialize(String aSerializedData, String aKey) throws IOException {
+        if (!createNewSession()) {
+            throw new OlmException(OlmException.EXCEPTION_CODE_INIT_ACCOUNT_CREATION,OlmException.EXCEPTION_MSG_INIT_ACCOUNT_CREATION);
+        }
 
-        if(null == aErrorMsg) {
-            Log.e(LOG_TAG, "## initWithSerializedData(): invalid input error parameter");
-        } else {
-            aErrorMsg.setLength(0);
-            try {
-                if (TextUtils.isEmpty(aSerializedData) || TextUtils.isEmpty(aKey)) {
-                    Log.e(LOG_TAG, "## initWithSerializedData(): invalid input parameters");
-                } else if (null == (jniError = initWithSerializedDataJni(aSerializedData.getBytes("UTF-8"), aKey.getBytes("UTF-8")))) {
-                    retCode = true;
-                } else {
-                    aErrorMsg.append(jniError);
-                }
-            } catch (Exception e) {
-                Log.e(LOG_TAG, "## initWithSerializedData() failed " + e.getMessage());
-                aErrorMsg.append(e.getMessage());
+        StringBuffer errorMsg = new StringBuffer();
+
+        try {
+            String jniError;
+            if (TextUtils.isEmpty(aSerializedData) || TextUtils.isEmpty(aKey)) {
+                Log.e(LOG_TAG, "## deserialize(): invalid input parameters");
+                errorMsg.append("invalid input parameters");
+            } else if (null != (jniError = deserializeJni(aSerializedData.getBytes("UTF-8"), aKey.getBytes("UTF-8")))) {
+                errorMsg.append(jniError);
             }
+        } catch (Exception e) {
+            Log.e(LOG_TAG, "## deserialize() failed " + e.getMessage());
+            errorMsg.append(e.getMessage());
         }
 
-        return retCode;
+        if (errorMsg.length() > 0) {
+            releaseSession();
+            throw new OlmException(OlmException.EXCEPTION_CODE_ACCOUNT_DESERIALIZATION, String.valueOf(errorMsg));
+        }
     }
+
     /**
-     * JNI counter part of {@link #initWithSerializedData(String, String, StringBuffer)}.
+     * JNI counter part of {@link #deserialize(String, String)}.
      * @param aSerializedData pickled session in a base64 string format
-     * @param aKey key used to encrypted in {@link #serializeDataWithKey(String, StringBuffer)}
+     * @param aKey key used to encrypted in {@link #serialize(String, StringBuffer)}
      * @return null if operation succeed, an error message if operation failed
      */
-    private native String initWithSerializedDataJni(byte[] aSerializedData, byte[] aKey);
-
-    /**
-     * Return true the object resources have been released.<br>
-     * @return true the object resources have been released
-     */
-    public boolean isReleased() {
-        return (0 == mNativeId);
-    }
+    private native String deserializeJni(byte[] aSerializedData, byte[] aKey);
 }
diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmOutboundGroupSession.java b/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmOutboundGroupSession.java
index b9c21ff..66a44d2 100644
--- a/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmOutboundGroupSession.java
+++ b/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmOutboundGroupSession.java
@@ -70,105 +70,6 @@ public class OlmOutboundGroupSession extends CommonSerializeUtils implements Ser
     }
 
     /**
-     * Kick off the serialization mechanism.
-     * @param aOutStream output stream for serializing
-     * @throws IOException exception
-     */
-    private void writeObject(ObjectOutputStream aOutStream) throws IOException {
-        serializeObject(aOutStream);
-    }
-
-    /**
-     * Kick off the deserialization mechanism.
-     * @param aInStream input stream
-     * @throws IOException exception
-     * @throws ClassNotFoundException exception
-     */
-    private void readObject(ObjectInputStream aInStream) throws IOException, ClassNotFoundException {
-        deserializeObject(aInStream);
-    }
-
-    @Override
-    protected boolean createNewObjectFromSerialization() {
-        return createNewSession();
-    }
-
-    @Override
-    protected void releaseObjectFromSerialization() {
-        releaseSession();
-    }
-
-    /**
-     * Return the current outbound group session as a base64 serialized string.<br>
-     * The session is serialized and encrypted with aKey.
-     * In case of failure, an error human readable
-     * description is provide in aErrorMsg.
-     * @param aKey encryption key
-     * @param aErrorMsg error message description
-     * @return pickled base64 string if operation succeed, null otherwise
-     */
-    @Override
-    protected String serializeDataWithKey(String aKey, StringBuffer aErrorMsg) {
-        String pickleRetValue = null;
-
-        // sanity check
-        if(null == aErrorMsg) {
-            Log.e(LOG_TAG,"## serializeDataWithKey(): invalid parameter - aErrorMsg=null");
-        } else if(TextUtils.isEmpty(aKey)) {
-            aErrorMsg.append("Invalid input parameters in serializeDataWithKey()");
-        } else {
-            aErrorMsg.setLength(0);
-            try {
-                pickleRetValue = serializeDataWithKeyJni(aKey.getBytes("UTF-8"), aErrorMsg);
-            } catch (Exception e) {
-                Log.e(LOG_TAG,"## serializeDataWithKey(): failed " + e.getMessage());
-                aErrorMsg.append(e.getMessage());
-            }
-        }
-
-        return pickleRetValue;
-    }
-    private native String serializeDataWithKeyJni(byte[] aKey, StringBuffer aErrorMsg);
-
-
-    /**
-     * Load an outbound group session from a pickled base64 string.<br>
-     * See {@link #serializeDataWithKey(String, StringBuffer)}
-     * @param aSerializedData pickled outbound group session in a base64 string format
-     * @param aKey encrypting key used in {@link #serializeDataWithKey(String, StringBuffer)}
-     * @param aErrorMsg error message description
-     * @return true if operation succeed, false otherwise
-     */
-    @Override
-    protected boolean initWithSerializedData(String aSerializedData, String aKey, StringBuffer aErrorMsg) {
-        boolean retCode = false;
-        String jniError;
-
-        if(null == aErrorMsg) {
-            Log.e(LOG_TAG, "## initWithSerializedData(): invalid input error parameter");
-        } else {
-            aErrorMsg.setLength(0);
-
-            try {
-                if (TextUtils.isEmpty(aSerializedData) || TextUtils.isEmpty(aKey)) {
-                    Log.e(LOG_TAG, "## initWithSerializedData(): invalid input parameters");
-                } else if (null == (jniError = initWithSerializedDataJni(aSerializedData.getBytes("UTF-8"), aKey.getBytes("UTF-8")))) {
-                    retCode = true;
-                } else {
-                    aErrorMsg.append(jniError);
-                }
-            } catch (Exception e) {
-                Log.e(LOG_TAG, "## initWithSerializedData(): failed " + e.getMessage());
-                aErrorMsg.append(e.getMessage());
-            }
-        }
-
-        return retCode;
-    }
-    private native String initWithSerializedDataJni(byte[] aSerializedData, byte[] aKey);
-
-
-    /**
      * Release native session and invalid its JAVA reference counter part.<br>
      * Public API for {@link #releaseSessionJni()}.
      */
@@ -204,6 +105,14 @@ public class OlmOutboundGroupSession extends CommonSerializeUtils implements Ser
     private native long createNewSessionJni();
 
     /**
+     * Return true the object resources have been released.<br>
+     * @return true the object resources have been released
+     */
+    public boolean isReleased() {
+        return (0 == mNativeId);
+    }
+
+    /**
      * Start a new outbound group session.<br>
      * @return 0 if operation succeed, -1 otherwise
      */
@@ -290,11 +199,96 @@ public class OlmOutboundGroupSession extends CommonSerializeUtils implements Ser
     }
     private native byte[] encryptMessageJni(byte[] aClearMsgBuffer, StringBuffer aErrorMsg);
 
+
+    //==============================================================================================================
+    // Serialization management
+    //==============================================================================================================
+
     /**
-     * Return true the object resources have been released.<br>
-     * @return true the object resources have been released
+     * Kick off the serialization mechanism.
+     * @param aOutStream output stream for serializing
+     * @throws IOException exception
      */
-    public boolean isReleased() {
-        return (0 == mNativeId);
+    private void writeObject(ObjectOutputStream aOutStream) throws IOException {
+        serialize(aOutStream);
     }
+
+    /**
+     * Kick off the deserialization mechanism.
+     * @param aInStream input stream
+     * @throws IOException exception
+     * @throws ClassNotFoundException exception
+     */
+    private void readObject(ObjectInputStream aInStream) throws IOException, ClassNotFoundException {
+        deserialize(aInStream);
+    }
+
+    /**
+     * Return the current outbound group session as a base64 serialized string.<br>
+     * The session is serialized and encrypted with aKey.
+     * In case of failure, an error human readable
+     * description is provide in aErrorMsg.
+     * @param aKey encryption key
+     * @param aErrorMsg error message description
+     * @return pickled base64 string if operation succeed, null otherwise
+     */
+    @Override
+    protected String serialize(String aKey, StringBuffer aErrorMsg) {
+        String pickleRetValue = null;
+
+        // sanity check
+        if(null == aErrorMsg) {
+            Log.e(LOG_TAG,"## serialize(): invalid parameter - aErrorMsg=null");
+        } else if(TextUtils.isEmpty(aKey)) {
+            aErrorMsg.append("Invalid input parameters in serialize()");
+        } else {
+            aErrorMsg.setLength(0);
+            try {
+                pickleRetValue = serializeJni(aKey.getBytes("UTF-8"), aErrorMsg);
+            } catch (Exception e) {
+                Log.e(LOG_TAG,"## serialize(): failed " + e.getMessage());
+                aErrorMsg.append(e.getMessage());
+            }
+        }
+
+        return pickleRetValue;
+    }
+    private native String serializeJni(byte[] aKey, StringBuffer aErrorMsg);
+
+
+    /**
+     * Loads an account from a pickled base64 string.<br>
+     * See {@link #serialize(String, StringBuffer)}
+     * @param aSerializedData pickled account in a base64 string format
+     * @param aKey key used to encrypted
+     */
+    @Override
+    protected void deserialize(String aSerializedData, String aKey) throws IOException {
+        if (!createNewSession()) {
+            throw new OlmException(OlmException.EXCEPTION_CODE_INIT_ACCOUNT_CREATION,OlmException.EXCEPTION_MSG_INIT_ACCOUNT_CREATION);
+        }
+
+        StringBuffer errorMsg = new StringBuffer();
+
+        try {
+            String jniError;
+            if (TextUtils.isEmpty(aSerializedData) || TextUtils.isEmpty(aKey)) {
+                Log.e(LOG_TAG, "## deserialize(): invalid input parameters");
+                errorMsg.append("invalid input parameters");
+            } else if (null != (jniError = deserializeJni(aSerializedData.getBytes("UTF-8"), aKey.getBytes("UTF-8")))) {
+                errorMsg.append(jniError);
+            }
+        } catch (Exception e) {
+            Log.e(LOG_TAG, "## deserialize() failed " + e.getMessage());
+            errorMsg.append(e.getMessage());
+        }
+
+        if (errorMsg.length() > 0) {
+            releaseSession();
+            throw new OlmException(OlmException.EXCEPTION_CODE_ACCOUNT_DESERIALIZATION, String.valueOf(errorMsg));
+        }
+    }
+
+    private native String deserializeJni(byte[] aSerializedData, byte[] aKey);
+
 }
diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmSession.java b/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmSession.java
index 85804a1..36a95a1 100644
--- a/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmSession.java
+++ b/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmSession.java
@@ -28,8 +28,8 @@ import java.io.Serializable;
 /**
  * Session class used to create Olm sessions in conjunction with {@link OlmAccount} class.<br>
  * Olm session is used to encrypt data between devices, especially to create Olm group sessions (see {@link OlmOutboundGroupSession} and {@link OlmInboundGroupSession}).<br>
- * To establish an Olm session with Bob, Alice calls {@link #initOutboundSessionWithAccount(OlmAccount, String, String)} with Bob's identity and onetime keys. Then Alice generates an encrypted PRE_KEY message ({@link #encryptMessage(String)})
- * used by Bob to open the Olm session in his side with {@link #initOutboundSessionWithAccount(OlmAccount, String, String)}.
+ * To establish an Olm session with Bob, Alice calls {@link #initOutboundSession(OlmAccount, String, String)} with Bob's identity and onetime keys. Then Alice generates an encrypted PRE_KEY message ({@link #encryptMessage(String)})
+ * used by Bob to open the Olm session in his side with {@link #initOutboundSession(OlmAccount, String, String)}.
  * From this step on, messages can be exchanged by using {@link #encryptMessage(String)} and {@link #decryptMessage(OlmMessage)}.
  * <br><br>Detailed implementation guide is available at <a href="http://matrix.org/docs/guides/e2e_implementation.html">Implementing End-to-End Encryption in Matrix clients</a>.
  */
@@ -49,104 +49,6 @@ public class OlmSession extends CommonSerializeUtils implements Serializable {
     }
 
     /**
-     * Kick off the serialization mechanism.
-     * @param aOutStream output stream for serializing
-     * @throws IOException exception
-     */
-    private void writeObject(ObjectOutputStream aOutStream) throws IOException {
-        serializeObject(aOutStream);
-    }
-
-    /**
-     * Kick off the deserialization mechanism.
-     * @param aInStream input stream
-     * @throws IOException exception
-     * @throws ClassNotFoundException exception
-     */
-    private void readObject(ObjectInputStream aInStream) throws IOException, ClassNotFoundException {
-        deserializeObject(aInStream);
-    }
-
-    @Override
-    protected boolean createNewObjectFromSerialization() {
-        return createNewSession();
-    }
-
-    @Override
-    protected void releaseObjectFromSerialization() {
-        releaseSession();
-    }
-
-    /**
-     * Return a session as a base64 string.<br>
-     * The account is serialized and encrypted with aKey.
-     * In case of failure, an error human readable
-     * description is provide in aErrorMsg.
-     * @param aKey encryption key
-     * @param aErrorMsg error message description
-     * @return pickled base64 string if operation succeed, null otherwise
-     */
-    @Override
-    protected String serializeDataWithKey(String aKey, StringBuffer aErrorMsg) {
-        String pickleRetValue = null;
-
-        // sanity check
-        if(null == aErrorMsg) {
-            Log.e(LOG_TAG,"## serializeDataWithKey(): invalid parameter - aErrorMsg=null");
-        } else if(TextUtils.isEmpty(aKey)) {
-            aErrorMsg.append("Invalid input parameters in serializeDataWithKey()");
-        } else {
-            aErrorMsg.setLength(0);
-            try {
-                pickleRetValue = serializeDataWithKeyJni(aKey.getBytes("UTF-8"), aErrorMsg);
-            } catch (Exception e) {
-                Log.e(LOG_TAG,"## serializeDataWithKey(): failed " + e.getMessage());
-                aErrorMsg.append(e.getMessage());
-            }
-        }
-
-        return pickleRetValue;
-    }
-    private native String serializeDataWithKeyJni(byte[] aKey, StringBuffer aErrorMsg);
-
-
-    /**
-     * Loads a session from a pickled base64 string.<br>
-     * See {@link #serializeDataWithKey(String, StringBuffer)}
-     * @param aSerializedData pickled account in a base64 string format
-     * @param aKey key used to encrypted
-     * @param aErrorMsg error message description
-     * @return true if operation succeed, false otherwise
-     */
-    @Override
-    protected boolean initWithSerializedData(String aSerializedData, String aKey, StringBuffer aErrorMsg) {
-        boolean retCode = false;
-        String jniError;
-
-        if(null == aErrorMsg) {
-            Log.e(LOG_TAG, "## initWithSerializedData(): invalid input error parameter");
-        } else {
-            aErrorMsg.setLength(0);
-
-            try {
-                if (TextUtils.isEmpty(aSerializedData) || TextUtils.isEmpty(aKey)) {
-                    Log.e(LOG_TAG, "## initWithSerializedData(): invalid input parameters");
-                } else if (null == (jniError = initWithSerializedDataJni(aSerializedData.getBytes("UTF-8"), aKey.getBytes("UTF-8")))) {
-                    retCode = true;
-                } else {
-                    aErrorMsg.append(jniError);
-                }
-            } catch (Exception e) {
-                Log.e(LOG_TAG, "## initWithSerializedData(): failed " + e.getMessage());
-                aErrorMsg.append(e.getMessage());
-            }
-        }
-
-        return retCode;
-    }
-    private native String initWithSerializedDataJni(byte[] aSerializedData, byte[] aKey);
-
-    /**
      * Getter on the session ID.
      * @return native session ID
      */
@@ -189,7 +91,6 @@ public class OlmSession extends CommonSerializeUtils implements Serializable {
      */
     private native long initNewSessionJni();
 
-
     /**
      * Create a native account instance without any initialization.<br>
      * Since the account is left uninitialized, this
@@ -210,6 +111,14 @@ public class OlmSession extends CommonSerializeUtils implements Serializable {
     private native long createNewSessionJni();
 
     /**
+     * Return true the object resources have been released.<br>
+     * @return true the object resources have been released
+     */
+    public boolean isReleased() {
+        return (0 == mNativeId);
+    }
+
+    /**
      * Creates a new out-bound session for sending messages to a recipient
      * identified by an identity key and a one time key.<br>
      * @param aAccount the account to associate with this session
@@ -217,7 +126,7 @@ public class OlmSession extends CommonSerializeUtils implements Serializable {
      * @param aTheirOneTimeKey the one time key of the recipient
      * @return 0 if operation succeed, -1 otherwise
      */
-    public int initOutboundSessionWithAccount(OlmAccount aAccount, String aTheirIdentityKey, String aTheirOneTimeKey) {
+    public int initOutboundSession(OlmAccount aAccount, String aTheirIdentityKey, String aTheirOneTimeKey) {
         int retCode=-1;
 
         if ((null == aAccount) || TextUtils.isEmpty(aTheirIdentityKey) || TextUtils.isEmpty(aTheirOneTimeKey)) {
@@ -226,7 +135,7 @@ public class OlmSession extends CommonSerializeUtils implements Serializable {
             try {
                 retCode = initOutboundSessionJni(aAccount.getOlmAccountId(), aTheirIdentityKey.getBytes("UTF-8"), aTheirOneTimeKey.getBytes("UTF-8"));
             } catch (Exception e) {
-                Log.e(LOG_TAG, "## initOutboundSessionWithAccount(): " + e.getMessage());
+                Log.e(LOG_TAG, "## initOutboundSession(): " + e.getMessage());
             }
         }
 
@@ -243,9 +152,9 @@ public class OlmSession extends CommonSerializeUtils implements Serializable {
      * @param aPreKeyMsg PRE KEY message
      * @exception Exception the failure reason
      */
-    public void initInboundSessionWithAccount(OlmAccount aAccount, String aPreKeyMsg) throws Exception {
+    public void initInboundSession(OlmAccount aAccount, String aPreKeyMsg) throws Exception {
         if ((null == aAccount) || TextUtils.isEmpty(aPreKeyMsg)){
-            Log.e(LOG_TAG, "## initInboundSessionWithAccount(): invalid input parameters");
+            Log.e(LOG_TAG, "## initInboundSession(): invalid input parameters");
             throw new Exception("invalid input parameters");
         } else {
             StringBuffer errorMsg = new StringBuffer();
@@ -253,7 +162,7 @@ public class OlmSession extends CommonSerializeUtils implements Serializable {
             try {
                 initInboundSessionJni(aAccount.getOlmAccountId(), aPreKeyMsg.getBytes("UTF-8"), errorMsg);
             } catch (Exception e) {
-                Log.e(LOG_TAG, "## initInboundSessionWithAccount(): " + e.getMessage());
+                Log.e(LOG_TAG, "## initInboundSession(): " + e.getMessage());
                 errorMsg.append(errorMsg);
             }
 
@@ -276,16 +185,16 @@ public class OlmSession extends CommonSerializeUtils implements Serializable {
      * @param aPreKeyMsg PRE KEY message
      * @return 0 if operation succeed, -1 otherwise
      */
-    public int initInboundSessionWithAccountFrom(OlmAccount aAccount, String aTheirIdentityKey, String aPreKeyMsg) {
+    public int initInboundSessionFrom(OlmAccount aAccount, String aTheirIdentityKey, String aPreKeyMsg) {
         int retCode=-1;
 
         if((null==aAccount) || TextUtils.isEmpty(aPreKeyMsg)){
-            Log.e(LOG_TAG, "## initInboundSessionWithAccount(): invalid input parameters");
+            Log.e(LOG_TAG, "## initInboundSessionFrom(): invalid input parameters");
         } else {
             try {
                 retCode = initInboundSessionFromIdKeyJni(aAccount.getOlmAccountId(), aTheirIdentityKey.getBytes("UTF-8"), aPreKeyMsg.getBytes("UTF-8"));
             } catch (Exception e) {
-                Log.e(LOG_TAG, "## initInboundSessionWithAccountFrom(): " + e.getMessage());
+                Log.e(LOG_TAG, "## initInboundSessionFrom(): " + e.getMessage());
             }
         }
 
@@ -400,12 +309,94 @@ public class OlmSession extends CommonSerializeUtils implements Serializable {
 
     private native byte[] decryptMessageJni(OlmMessage aEncryptedMsg);
 
+    //==============================================================================================================
+    // Serialization management
+    //==============================================================================================================
+
     /**
-     * Return true the object resources have been released.<br>
-     * @return true the object resources have been released
+     * Kick off the serialization mechanism.
+     * @param aOutStream output stream for serializing
+     * @throws IOException exception
      */
-    public boolean isReleased() {
-        return (0 == mNativeId);
+    private void writeObject(ObjectOutputStream aOutStream) throws IOException {
+        serialize(aOutStream);
     }
+
+    /**
+     * Kick off the deserialization mechanism.
+     * @param aInStream input stream
+     * @throws IOException exception
+     * @throws ClassNotFoundException exception
+     */
+    private void readObject(ObjectInputStream aInStream) throws IOException, ClassNotFoundException {
+        deserialize(aInStream);
+    }
+
+    /**
+     * Return a session as a base64 string.<br>
+     * The account is serialized and encrypted with aKey.
+     * In case of failure, an error human readable
+     * description is provide in aErrorMsg.
+     * @param aKey encryption key
+     * @param aErrorMsg error message description
+     * @return pickled base64 string if operation succeed, null otherwise
+     */
+    @Override
+    protected String serialize(String aKey, StringBuffer aErrorMsg) {
+        String pickleRetValue = null;
+
+        // sanity check
+        if(null == aErrorMsg) {
+            Log.e(LOG_TAG,"## serializeDataWithKey(): invalid parameter - aErrorMsg=null");
+        } else if(TextUtils.isEmpty(aKey)) {
+            aErrorMsg.append("Invalid input parameters in serializeDataWithKey()");
+        } else {
+            aErrorMsg.setLength(0);
+            try {
+                pickleRetValue = serializeJni(aKey.getBytes("UTF-8"), aErrorMsg);
+            } catch (Exception e) {
+                Log.e(LOG_TAG,"## serializeDataWithKey(): failed " + e.getMessage());
+                aErrorMsg.append(e.getMessage());
+            }
+        }
+
+        return pickleRetValue;
+    }
+    private native String serializeJni(byte[] aKey, StringBuffer aErrorMsg);
+
+    /**
+     * Loads an account from a pickled base64 string.<br>
+     * See {@link #serialize(String, StringBuffer)}
+     * @param aSerializedData pickled account in a base64 string format
+     * @param aKey key used to encrypted
+     */
+    @Override
+    protected void deserialize(String aSerializedData, String aKey) throws IOException {
+        if (!createNewSession()) {
+            throw new OlmException(OlmException.EXCEPTION_CODE_INIT_ACCOUNT_CREATION,OlmException.EXCEPTION_MSG_INIT_ACCOUNT_CREATION);
+        }
+
+        StringBuffer errorMsg = new StringBuffer();
+
+        try {
+            String jniError;
+            if (TextUtils.isEmpty(aSerializedData) || TextUtils.isEmpty(aKey)) {
+                Log.e(LOG_TAG, "## deserialize(): invalid input parameters");
+                errorMsg.append("invalid input parameters");
+            } else if (null != (jniError = deserializeJni(aSerializedData.getBytes("UTF-8"), aKey.getBytes("UTF-8")))) {
+                errorMsg.append(jniError);
+            }
+        } catch (Exception e) {
+            Log.e(LOG_TAG, "## deserialize() failed " + e.getMessage());
+            errorMsg.append(e.getMessage());
+        }
+
+        if (errorMsg.length() > 0) {
+            releaseSession();
+            throw new OlmException(OlmException.EXCEPTION_CODE_ACCOUNT_DESERIALIZATION, String.valueOf(errorMsg));
+        }
+    }
+
+    private native String deserializeJni(byte[] aSerializedData, byte[] aKey);
 }
 
diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_account.cpp b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_account.cpp
index 06709e7..d57e55b 100644
--- a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_account.cpp
+++ b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_account.cpp
@@ -476,7 +476,7 @@ JNIEXPORT jbyteArray OLM_ACCOUNT_FUNC_DEF(signMessageJni)(JNIEnv *env, jobject t
 * @param[out] aErrorMsg error message set if operation failed
 * @return a base64 string if operation succeed, null otherwise
 **/
-JNIEXPORT jbyteArray OLM_ACCOUNT_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env, jobject thiz, jbyteArray aKeyBuffer, jobject aErrorMsg)
+JNIEXPORT jbyteArray OLM_ACCOUNT_FUNC_DEF(serializeJni)(JNIEnv *env, jobject thiz, jbyteArray aKeyBuffer, jobject aErrorMsg)
 {
     jbyteArray pickledDataRetValue = 0;
     jclass errorMsgJClass = 0;
@@ -485,44 +485,44 @@ JNIEXPORT jbyteArray OLM_ACCOUNT_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env,
     jbyte* keyPtr = NULL;
     OlmAccount* accountPtr = NULL;
 
-    LOGD("## serializeDataWithKeyJni(): IN");
+    LOGD("## serializeJni(): IN");
 
     if (!aKeyBuffer)
     {
-        LOGE(" ## serializeDataWithKeyJni(): failure - invalid key");
+        LOGE(" ## serializeJni(): failure - invalid key");
     }
     else if (!aErrorMsg)
     {
-        LOGE(" ## serializeDataWithKeyJni(): failure - invalid error object");
+        LOGE(" ## serializeJni(): failure - invalid error object");
     }
     else if (!(accountPtr = (OlmAccount*)getAccountInstanceId(env,thiz)))
     {
-       LOGE(" ## serializeDataWithKeyJni(): failure - invalid account ptr");
+       LOGE(" ## serializeJni(): failure - invalid account ptr");
     }
     else if (!(errorMsgJClass = env->GetObjectClass(aErrorMsg)))
     {
-        LOGE(" ## serializeDataWithKeyJni(): failure - unable to get error class");
+        LOGE(" ## serializeJni(): failure - unable to get error class");
     }
     else if (!(errorMsgMethodId = env->GetMethodID(errorMsgJClass, "append", "(Ljava/lang/String;)Ljava/lang/StringBuffer;")))
     {
-        LOGE(" ## serializeDataWithKeyJni(): failure - unable to get error method ID");
+        LOGE(" ## serializeJni(): failure - unable to get error method ID");
     }
     else if (!(keyPtr = env->GetByteArrayElements(aKeyBuffer, NULL)))
     {
-        LOGE(" ## serializeDataWithKeyJni(): failure - keyPtr JNI allocation OOM");
+        LOGE(" ## serializeJni(): failure - keyPtr JNI allocation OOM");
     }
     else
     {
         size_t pickledLength = olm_pickle_account_length(accountPtr);
         size_t keyLength = (size_t)env->GetArrayLength(aKeyBuffer);
-        LOGD(" ## serializeDataWithKeyJni(): pickledLength=%lu keyLength=%lu",static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength));
-        LOGD(" ## serializeDataWithKeyJni(): key=%s",(char const *)keyPtr);
+        LOGD(" ## serializeJni(): pickledLength=%lu keyLength=%lu",static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength));
+        LOGD(" ## serializeJni(): key=%s",(char const *)keyPtr);
 
         void *pickledPtr = malloc((pickledLength+1)*sizeof(uint8_t));
 
         if (!pickledPtr)
         {
-            LOGE(" ## serializeDataWithKeyJni(): failure - pickledPtr buffer OOM");
+            LOGE(" ## serializeJni(): failure - pickledPtr buffer OOM");
         }
         else
         {
@@ -534,7 +534,7 @@ JNIEXPORT jbyteArray OLM_ACCOUNT_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env,
             if (result == olm_error())
             {
                 const char *errorMsgPtr = olm_account_last_error(accountPtr);
-                LOGE(" ## serializeDataWithKeyJni(): failure - olm_pickle_account() Msg=%s",errorMsgPtr);
+                LOGE(" ## serializeJni(): failure - olm_pickle_account() Msg=%s",errorMsgPtr);
 
                 if(0 != (errorJstring = env->NewStringUTF(errorMsgPtr)))
                 {
@@ -546,7 +546,7 @@ JNIEXPORT jbyteArray OLM_ACCOUNT_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env,
                 // build success output
                 (static_cast<char*>(pickledPtr))[pickledLength] = static_cast<char>('\0');
 
-                LOGD(" ## serializeDataWithKeyJni(): success - result=%lu pickled=%s", static_cast<long unsigned int>(result), static_cast<char*>(pickledPtr));
+                LOGD(" ## serializeJni(): success - result=%lu pickled=%s", static_cast<long unsigned int>(result), static_cast<char*>(pickledPtr));
 
                 pickledDataRetValue = env->NewByteArray(pickledLength+1);
                 env->SetByteArrayRegion(pickledDataRetValue, 0 , pickledLength+1, (jbyte*)pickledPtr);
@@ -566,42 +566,42 @@ JNIEXPORT jbyteArray OLM_ACCOUNT_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env,
 }
 
 
-JNIEXPORT jstring OLM_ACCOUNT_FUNC_DEF(initWithSerializedDataJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedDataBuffer, jbyteArray aKeyBuffer)
+JNIEXPORT jstring OLM_ACCOUNT_FUNC_DEF(deserializeJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedDataBuffer, jbyteArray aKeyBuffer)
 {
     OlmAccount* accountPtr = NULL;
     jstring errorMessageRetValue = 0;
     jbyte* keyPtr = NULL;
     jbyte* pickledPtr = NULL;
 
-    LOGD("## initWithSerializedDataJni(): IN");
+    LOGD("## deserializeJni(): IN");
 
     if (!aKeyBuffer)
     {
-        LOGE(" ## initWithSerializedDataJni(): failure - invalid key");
+        LOGE(" ## deserializeJni(): failure - invalid key");
     }
     else if (!aSerializedDataBuffer)
     {
-        LOGE(" ## initWithSerializedDataJni(): failure - serialized data");
+        LOGE(" ## deserializeJni(): failure - serialized data");
     }
     else if (!(accountPtr = (OlmAccount*)getAccountInstanceId(env,thiz)))
     {
-        LOGE(" ## initWithSerializedDataJni(): failure - account failure OOM");
+        LOGE(" ## deserializeJni(): failure - account failure OOM");
     }
     else if (!(keyPtr = env->GetByteArrayElements(aKeyBuffer, 0)))
     {
-        LOGE(" ## initWithSerializedDataJni(): failure - keyPtr JNI allocation OOM");
+        LOGE(" ## deserializeJni(): failure - keyPtr JNI allocation OOM");
     }
     else if (!(pickledPtr = env->GetByteArrayElements(aSerializedDataBuffer, 0)))
     {
-        LOGE(" ## initWithSerializedDataJni(): failure - pickledPtr JNI allocation OOM");
+        LOGE(" ## deserializeJni(): failure - pickledPtr JNI allocation OOM");
     }
     else
     {
         size_t pickledLength = (size_t)env->GetArrayLength(aSerializedDataBuffer);
         size_t keyLength = (size_t)env->GetArrayLength(aKeyBuffer);
-        LOGD(" ## initWithSerializedDataJni(): pickledLength=%lu keyLength=%lu",static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength));
-        LOGD(" ## initWithSerializedDataJni(): key=%s",(char const *)keyPtr);
-        LOGD(" ## initWithSerializedDataJni(): pickled=%s",(char const *)pickledPtr);
+        LOGD(" ## deserializeJni(): pickledLength=%lu keyLength=%lu",static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength));
+        LOGD(" ## deserializeJni(): key=%s",(char const *)keyPtr);
+        LOGD(" ## deserializeJni(): pickled=%s",(char const *)pickledPtr);
 
         size_t result = olm_unpickle_account(accountPtr,
                                              (void const *)keyPtr,
@@ -611,12 +611,12 @@ JNIEXPORT jstring OLM_ACCOUNT_FUNC_DEF(initWithSerializedDataJni)(JNIEnv *env, j
         if (result == olm_error())
         {
             const char *errorMsgPtr = olm_account_last_error(accountPtr);
-            LOGE(" ## initWithSerializedDataJni(): failure - olm_unpickle_account() Msg=%s",errorMsgPtr);
+            LOGE(" ## deserializeJni(): failure - olm_unpickle_account() Msg=%s",errorMsgPtr);
             errorMessageRetValue = env->NewStringUTF(errorMsgPtr);
         }
         else
         {
-            LOGD(" ## initWithSerializedDataJni(): success - result=%lu ", static_cast<long unsigned int>(result));
+            LOGD(" ## deserializeJni(): success - result=%lu ", static_cast<long unsigned int>(result));
         }
     }
 
diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_account.h b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_account.h
index c866dbc..94a0381 100644
--- a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_account.h
+++ b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_account.h
@@ -47,8 +47,8 @@ JNIEXPORT jint OLM_ACCOUNT_FUNC_DEF(markOneTimeKeysAsPublishedJni)(JNIEnv *env,
 JNIEXPORT jbyteArray OLM_ACCOUNT_FUNC_DEF(signMessageJni)(JNIEnv *env, jobject thiz, jbyteArray aMessage);
 
 // serialization
-JNIEXPORT jbyteArray OLM_ACCOUNT_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env, jobject thiz, jbyteArray aKeyBuffer, jobject aErrorMsg);
-JNIEXPORT jstring OLM_ACCOUNT_FUNC_DEF(initWithSerializedDataJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedDataBuffer, jbyteArray aKeyBuffer);
+JNIEXPORT jbyteArray OLM_ACCOUNT_FUNC_DEF(serializeJni)(JNIEnv *env, jobject thiz, jbyteArray aKeyBuffer, jobject aErrorMsg);
+JNIEXPORT jstring OLM_ACCOUNT_FUNC_DEF(deserializeJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedDataBuffer, jbyteArray aKeyBuffer);
 
 #ifdef __cplusplus
 }
diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_inbound_group_session.cpp b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_inbound_group_session.cpp
index ca47dbb..d396eb9 100644
--- a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_inbound_group_session.cpp
+++ b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_inbound_group_session.cpp
@@ -86,41 +86,41 @@ JNIEXPORT jlong OLM_INBOUND_GROUP_SESSION_FUNC_DEF(createNewSessionJni)(JNIEnv *
  * @param aSessionKey session key from an outbound session
  * @return ERROR_CODE_OK if operation succeed, ERROR_CODE_KO otherwise
  */
-JNIEXPORT jint OLM_INBOUND_GROUP_SESSION_FUNC_DEF(initInboundGroupSessionWithSessionKeyJni)(JNIEnv *env, jobject thiz, jbyteArray aSessionKeyBuffer)
+JNIEXPORT jint OLM_INBOUND_GROUP_SESSION_FUNC_DEF(initInboundGroupSessionJni)(JNIEnv *env, jobject thiz, jbyteArray aSessionKeyBuffer)
 {
     jint retCode = ERROR_CODE_KO;
     OlmInboundGroupSession *sessionPtr = NULL;
     jbyte* sessionKeyPtr = NULL;
     size_t sessionResult;
 
-    LOGD("## initInboundGroupSessionWithSessionKeyJni(): inbound group session IN");
+    LOGD("## initInboundGroupSessionJni(): inbound group session IN");
 
     if (!(sessionPtr = (OlmInboundGroupSession*)getInboundGroupSessionInstanceId(env,thiz)))
     {
-        LOGE(" ## initInboundGroupSessionWithSessionKeyJni(): failure - invalid inbound group session instance");
+        LOGE(" ## initInboundGroupSessionJni(): failure - invalid inbound group session instance");
     }
     else if (!aSessionKeyBuffer)
     {
-        LOGE(" ## initInboundGroupSessionWithSessionKeyJni(): failure - invalid aSessionKey");
+        LOGE(" ## initInboundGroupSessionJni(): failure - invalid aSessionKey");
     }
     else if (!(sessionKeyPtr = env->GetByteArrayElements(aSessionKeyBuffer, 0)))
     {
-        LOGE(" ## initInboundSessionFromIdKeyJni(): failure - session key JNI allocation OOM");
+        LOGE(" ## initInboundGroupSessionJni(): failure - session key JNI allocation OOM");
     }
     else
     {
         size_t sessionKeyLength = (size_t)env->GetArrayLength(aSessionKeyBuffer);
-        LOGD(" ## initInboundSessionFromIdKeyJni(): sessionKeyLength=%lu",static_cast<long unsigned int>(sessionKeyLength));
+        LOGD(" ## initInboundGroupSessionJni(): sessionKeyLength=%lu",static_cast<long unsigned int>(sessionKeyLength));
 
         sessionResult = olm_init_inbound_group_session(sessionPtr, (const uint8_t*)sessionKeyPtr, sessionKeyLength);
         if (sessionResult == olm_error()) {
             const char *errorMsgPtr = olm_inbound_group_session_last_error(sessionPtr);
-            LOGE(" ## initInboundSessionFromIdKeyJni(): failure - init inbound session creation Msg=%s",errorMsgPtr);
+            LOGE(" ## initInboundGroupSessionJni(): failure - init inbound session creation Msg=%s",errorMsgPtr);
         }
         else
         {
             retCode = ERROR_CODE_OK;
-            LOGD(" ## initInboundSessionFromIdKeyJni(): success - result=%lu", static_cast<long unsigned int>(sessionResult));
+            LOGD(" ## initInboundGroupSessionJni(): success - result=%lu", static_cast<long unsigned int>(sessionResult));
         }
      }
 
@@ -337,7 +337,7 @@ JNIEXPORT jbyteArray OLM_INBOUND_GROUP_SESSION_FUNC_DEF(decryptMessageJni)(JNIEn
 * @param[out] aErrorMsg error message set if operation failed
 * @return a base64 string if operation succeed, null otherwise
 **/
-JNIEXPORT jbyteArray OLM_INBOUND_GROUP_SESSION_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env, jobject thiz, jbyteArray aKeyBuffer, jobject aErrorMsg)
+JNIEXPORT jbyteArray OLM_INBOUND_GROUP_SESSION_FUNC_DEF(serializeJni)(JNIEnv *env, jobject thiz, jbyteArray aKeyBuffer, jobject aErrorMsg)
 {
     jbyteArray pickledDataRet = 0;
 
@@ -346,44 +346,44 @@ JNIEXPORT jbyteArray OLM_INBOUND_GROUP_SESSION_FUNC_DEF(serializeDataWithKeyJni)
     jbyte* keyPtr = NULL;
     OlmInboundGroupSession* sessionPtr = NULL;
 
-    LOGD("## inbound group session serializeDataWithKeyJni(): IN");
+    LOGD("## inbound group session serializeJni(): IN");
 
     if (!(sessionPtr = (OlmInboundGroupSession*)getInboundGroupSessionInstanceId(env,thiz)))
     {
-        LOGE(" ## serializeDataWithKeyJni(): failure - invalid session ptr");
+        LOGE(" ## serializeJni(): failure - invalid session ptr");
     }
     else if (!aKeyBuffer)
     {
-        LOGE(" ## serializeDataWithKeyJni(): failure - invalid key");
+        LOGE(" ## serializeJni(): failure - invalid key");
     }
     else if (!aErrorMsg)
     {
-        LOGE(" ## serializeDataWithKeyJni(): failure - invalid error object");
+        LOGE(" ## serializeJni(): failure - invalid error object");
     }
     else if (!(errorMsgJClass = env->GetObjectClass(aErrorMsg)))
     {
-        LOGE(" ## serializeDataWithKeyJni(): failure - unable to get error class");
+        LOGE(" ## serializeJni(): failure - unable to get error class");
     }
     else if (!(errorMsgMethodId = env->GetMethodID(errorMsgJClass, "append", "(Ljava/lang/String;)Ljava/lang/StringBuffer;")))
     {
-        LOGE(" ## serializeDataWithKeyJni(): failure - unable to get error method ID");
+        LOGE(" ## serializeJni(): failure - unable to get error method ID");
     }
     else if (!(keyPtr = env->GetByteArrayElements(aKeyBuffer, 0)))
     {
-        LOGE(" ## serializeDataWithKeyJni(): failure - keyPtr JNI allocation OOM");
+        LOGE(" ## serializeJni(): failure - keyPtr JNI allocation OOM");
     }
     else
     {
         size_t pickledLength = olm_pickle_inbound_group_session_length(sessionPtr);
         size_t keyLength = (size_t)env->GetArrayLength(aKeyBuffer);
-        LOGD(" ## serializeDataWithKeyJni(): pickledLength=%lu keyLength=%lu", static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength));
-        LOGD(" ## serializeDataWithKeyJni(): key=%s",(char const *)keyPtr);
+        LOGD(" ## serializeJni(): pickledLength=%lu keyLength=%lu", static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength));
+        LOGD(" ## serializeJni(): key=%s",(char const *)keyPtr);
 
         void *pickledPtr = malloc((pickledLength+1)*sizeof(uint8_t));
 
         if (!pickledPtr)
         {
-            LOGE(" ## serializeDataWithKeyJni(): failure - pickledPtr buffer OOM");
+            LOGE(" ## serializeJni(): failure - pickledPtr buffer OOM");
         }
         else
         {
@@ -395,7 +395,7 @@ JNIEXPORT jbyteArray OLM_INBOUND_GROUP_SESSION_FUNC_DEF(serializeDataWithKeyJni)
             if (result == olm_error())
             {
                 const char *errorMsgPtr = olm_inbound_group_session_last_error(sessionPtr);
-                LOGE(" ## serializeDataWithKeyJni(): failure - olm_pickle_outbound_group_session() Msg=%s",errorMsgPtr);
+                LOGE(" ## serializeJni(): failure - olm_pickle_outbound_group_session() Msg=%s",errorMsgPtr);
 
                 jstring errorJstring = env->NewStringUTF(errorMsgPtr);
 
@@ -407,7 +407,7 @@ JNIEXPORT jbyteArray OLM_INBOUND_GROUP_SESSION_FUNC_DEF(serializeDataWithKeyJni)
             else
             {
              	(static_cast<char*>(pickledPtr))[pickledLength] = static_cast<char>('\0');
-                LOGD(" ## serializeDataWithKeyJni(): success - result=%lu pickled=%s", static_cast<long unsigned int>(result), static_cast<char*>(pickledPtr));
+                LOGD(" ## serializeJni(): success - result=%lu pickled=%s", static_cast<long unsigned int>(result), static_cast<char*>(pickledPtr));
 
                 pickledDataRet = env->NewByteArray(pickledLength);
                 env->SetByteArrayRegion(pickledDataRet, 0 , pickledLength, (jbyte*)pickledPtr);
@@ -427,42 +427,42 @@ JNIEXPORT jbyteArray OLM_INBOUND_GROUP_SESSION_FUNC_DEF(serializeDataWithKeyJni)
 }
 
 
-JNIEXPORT jstring OLM_INBOUND_GROUP_SESSION_FUNC_DEF(initWithSerializedDataJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedDataBuffer, jbyteArray aKeyBuffer)
+JNIEXPORT jstring OLM_INBOUND_GROUP_SESSION_FUNC_DEF(deserializeJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedDataBuffer, jbyteArray aKeyBuffer)
 {
     OlmInboundGroupSession* sessionPtr = NULL;
     jstring errorMessageRetValue = 0;
     jbyte* keyPtr = NULL;
     jbyte* pickledPtr = NULL;
 
-    LOGD("## initWithSerializedDataJni(): IN");
+    LOGD("## deserializeJni(): IN");
 
     if (!(sessionPtr = (OlmInboundGroupSession*)getInboundGroupSessionInstanceId(env,thiz)))
     {
-        LOGE(" ## initWithSerializedDataJni(): failure - session failure OOM");
+        LOGE(" ## deserializeJni(): failure - session failure OOM");
     }
     else if (!aKeyBuffer)
     {
-        LOGE(" ## initWithSerializedDataJni(): failure - invalid key");
+        LOGE(" ## deserializeJni(): failure - invalid key");
     }
     else if (!aSerializedDataBuffer)
     {
-        LOGE(" ## initWithSerializedDataJni(): failure - serialized data");
+        LOGE(" ## deserializeJni(): failure - serialized data");
     }
     else if (!(keyPtr = env->GetByteArrayElements(aKeyBuffer, 0)))
     {
-        LOGE(" ## initWithSerializedDataJni(): failure - keyPtr JNI allocation OOM");
+        LOGE(" ## deserializeJni(): failure - keyPtr JNI allocation OOM");
     }
     else if (!(pickledPtr = env->GetByteArrayElements(aSerializedDataBuffer, 0)))
     {
-        LOGE(" ## initWithSerializedDataJni(): failure - pickledPtr JNI allocation OOM");
+        LOGE(" ## deserializeJni(): failure - pickledPtr JNI allocation OOM");
     }
     else
     {
         size_t pickledLength = (size_t)env->GetArrayLength(aSerializedDataBuffer);
         size_t keyLength = (size_t)env->GetArrayLength(aKeyBuffer);
-        LOGD(" ## initWithSerializedDataJni(): pickledLength=%lu keyLength=%lu",static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength));
-        LOGD(" ## initWithSerializedDataJni(): key=%s",(char const *)keyPtr);
-        LOGD(" ## initWithSerializedDataJni(): pickled=%s",(char const *)pickledPtr);
+        LOGD(" ## deserializeJni(): pickledLength=%lu keyLength=%lu",static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength));
+        LOGD(" ## deserializeJni(): key=%s",(char const *)keyPtr);
+        LOGD(" ## deserializeJni(): pickled=%s",(char const *)pickledPtr);
 
         size_t result = olm_unpickle_inbound_group_session(sessionPtr,
                                                            (void const *)keyPtr,
@@ -472,12 +472,12 @@ JNIEXPORT jstring OLM_INBOUND_GROUP_SESSION_FUNC_DEF(initWithSerializedDataJni)(
         if (result == olm_error())
         {
             const char *errorMsgPtr = olm_inbound_group_session_last_error(sessionPtr);
-            LOGE(" ## initWithSerializedDataJni(): failure - olm_unpickle_inbound_group_session() Msg=%s",errorMsgPtr);
+            LOGE(" ## deserializeJni(): failure - olm_unpickle_inbound_group_session() Msg=%s",errorMsgPtr);
             errorMessageRetValue = env->NewStringUTF(errorMsgPtr);
         }
         else
         {
-            LOGD(" ## initWithSerializedDataJni(): success - result=%lu ", static_cast<long unsigned int>(result));
+            LOGD(" ## deserializeJni(): success - result=%lu ", static_cast<long unsigned int>(result));
         }
     }
 
diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_inbound_group_session.h b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_inbound_group_session.h
index 7ed6d8b..0ef55cf 100644
--- a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_inbound_group_session.h
+++ b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_inbound_group_session.h
@@ -32,13 +32,13 @@ extern "C" {
 JNIEXPORT void OLM_INBOUND_GROUP_SESSION_FUNC_DEF(releaseSessionJni)(JNIEnv *env, jobject thiz);
 JNIEXPORT jlong OLM_INBOUND_GROUP_SESSION_FUNC_DEF(createNewSessionJni)(JNIEnv *env, jobject thiz);
 
-JNIEXPORT jint OLM_INBOUND_GROUP_SESSION_FUNC_DEF(initInboundGroupSessionWithSessionKeyJni)(JNIEnv *env, jobject thiz, jbyteArray aSessionKeyBuffer);
+JNIEXPORT jint OLM_INBOUND_GROUP_SESSION_FUNC_DEF(initInboundGroupSessionJni)(JNIEnv *env, jobject thiz, jbyteArray aSessionKeyBuffer);
 JNIEXPORT jbyteArray OLM_INBOUND_GROUP_SESSION_FUNC_DEF(sessionIdentifierJni)(JNIEnv *env, jobject thiz);
 JNIEXPORT jbyteArray OLM_INBOUND_GROUP_SESSION_FUNC_DEF(decryptMessageJni)(JNIEnv *env, jobject thiz, jbyteArray aEncryptedMsg, jobject aDecryptIndex, jobject aErrorMsg);
 
 // serialization
-JNIEXPORT jbyteArray OLM_INBOUND_GROUP_SESSION_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env, jobject thiz, jbyteArray aKey, jobject aErrorMsg);
-JNIEXPORT jstring OLM_INBOUND_GROUP_SESSION_FUNC_DEF(initWithSerializedDataJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedData, jbyteArray aKey);
+JNIEXPORT jbyteArray OLM_INBOUND_GROUP_SESSION_FUNC_DEF(serializeJni)(JNIEnv *env, jobject thiz, jbyteArray aKey, jobject aErrorMsg);
+JNIEXPORT jstring OLM_INBOUND_GROUP_SESSION_FUNC_DEF(deserializeJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedData, jbyteArray aKey);
 
 
 #ifdef __cplusplus
diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_outbound_group_session.cpp b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_outbound_group_session.cpp
index aa0e5e7..4168742 100644
--- a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_outbound_group_session.cpp
+++ b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_outbound_group_session.cpp
@@ -372,7 +372,7 @@ JNIEXPORT jbyteArray OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(encryptMessageJni)(JNIE
 * @param[out] aErrorMsg error message set if operation failed
 * @return a base64 string if operation succeed, null otherwise
 **/
-JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env, jobject thiz, jbyteArray aKeyBuffer, jobject aErrorMsg)
+JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(serializeJni)(JNIEnv *env, jobject thiz, jbyteArray aKeyBuffer, jobject aErrorMsg)
 {
     jstring pickledDataRetValue = 0;
     jclass errorMsgJClass = 0;
@@ -381,44 +381,44 @@ JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(serializeDataWithKeyJni)(J
     jbyte* keyPtr = NULL;
     OlmOutboundGroupSession* sessionPtr = NULL;
 
-    LOGD("## outbound group session serializeDataWithKeyJni(): IN");
+    LOGD("## outbound group session serializeJni(): IN");
 
     if (!(sessionPtr = (OlmOutboundGroupSession*)getOutboundGroupSessionInstanceId(env,thiz)))
     {
-        LOGE(" ## serializeDataWithKeyJni(): failure - invalid session ptr");
+        LOGE(" ## serializeJni(): failure - invalid session ptr");
     }
     else if (!aKeyBuffer)
     {
-        LOGE(" ## serializeDataWithKeyJni(): failure - invalid key");
+        LOGE(" ## serializeJni(): failure - invalid key");
     }
     else if (!aErrorMsg)
     {
-        LOGE(" ## serializeDataWithKeyJni(): failure - invalid error object");
+        LOGE(" ## serializeJni(): failure - invalid error object");
     }
     else if (!(errorMsgJClass = env->GetObjectClass(aErrorMsg)))
     {
-        LOGE(" ## serializeDataWithKeyJni(): failure - unable to get error class");
+        LOGE(" ## serializeJni(): failure - unable to get error class");
     }
     else if (!(errorMsgMethodId = env->GetMethodID(errorMsgJClass, "append", "(Ljava/lang/String;)Ljava/lang/StringBuffer;")))
     {
-        LOGE(" ## serializeDataWithKeyJni(): failure - unable to get error method ID");
+        LOGE(" ## serializeJni(): failure - unable to get error method ID");
     }
     else if (!(keyPtr = env->GetByteArrayElements(aKeyBuffer, 0)))
     {
-        LOGE(" ## serializeDataWithKeyJni(): failure - keyPtr JNI allocation OOM");
+        LOGE(" ## serializeJni(): failure - keyPtr JNI allocation OOM");
     }
     else
     {
         size_t pickledLength = olm_pickle_outbound_group_session_length(sessionPtr);
         size_t keyLength = (size_t)env->GetArrayLength(aKeyBuffer);
-        LOGD(" ## serializeDataWithKeyJni(): pickledLength=%lu keyLength=%lu",static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength));
-        LOGD(" ## serializeDataWithKeyJni(): key=%s",(char const *)keyPtr);
+        LOGD(" ## serializeJni(): pickledLength=%lu keyLength=%lu",static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength));
+        LOGD(" ## serializeJni(): key=%s",(char const *)keyPtr);
 
         void *pickledPtr = malloc((pickledLength+1)*sizeof(uint8_t));
 
         if(!pickledPtr)
         {
-            LOGE(" ## serializeDataWithKeyJni(): failure - pickledPtr buffer OOM");
+            LOGE(" ## serializeJni(): failure - pickledPtr buffer OOM");
         }
         else
         {
@@ -430,7 +430,7 @@ JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(serializeDataWithKeyJni)(J
             if (result == olm_error())
             {
                 const char *errorMsgPtr = olm_outbound_group_session_last_error(sessionPtr);
-                LOGE(" ## serializeDataWithKeyJni(): failure - olm_pickle_outbound_group_session() Msg=%s",errorMsgPtr);
+                LOGE(" ## serializeJni(): failure - olm_pickle_outbound_group_session() Msg=%s",errorMsgPtr);
 
                 if (!(errorJstring = env->NewStringUTF(errorMsgPtr)))
                 {
@@ -442,7 +442,7 @@ JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(serializeDataWithKeyJni)(J
                 // build success output
                 (static_cast<char*>(pickledPtr))[pickledLength] = static_cast<char>('\0');
                 pickledDataRetValue = env->NewStringUTF((const char*)pickledPtr);
-                LOGD(" ## serializeDataWithKeyJni(): success - result=%lu pickled=%s", static_cast<long unsigned int>(result), static_cast<char*>(pickledPtr));
+                LOGD(" ## serializeJni(): success - result=%lu pickled=%s", static_cast<long unsigned int>(result), static_cast<char*>(pickledPtr));
             }
         }
 
@@ -459,42 +459,42 @@ JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(serializeDataWithKeyJni)(J
 }
 
 
-JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(initWithSerializedDataJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedDataBuffer, jbyteArray aKeyBuffer)
+JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(deserializeJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedDataBuffer, jbyteArray aKeyBuffer)
 {
     OlmOutboundGroupSession* sessionPtr = NULL;
     jstring errorMessageRetValue = 0;
     jbyte* keyPtr = NULL;
     jbyte* pickledPtr = NULL;
 
-    LOGD("## initWithSerializedDataJni(): IN");
+    LOGD("## deserializeJni(): IN");
 
     if (!(sessionPtr = (OlmOutboundGroupSession*)getOutboundGroupSessionInstanceId(env,thiz)))
     {
-        LOGE(" ## initWithSerializedDataJni(): failure - session failure OOM");
+        LOGE(" ## deserializeJni(): failure - session failure OOM");
     }
     else if (!aKeyBuffer)
     {
-        LOGE(" ## initWithSerializedDataJni(): failure - invalid key");
+        LOGE(" ## deserializeJni(): failure - invalid key");
     }
     else if (!aSerializedDataBuffer)
     {
-        LOGE(" ## initWithSerializedDataJni(): failure - serialized data");
+        LOGE(" ## deserializeJni(): failure - serialized data");
     }
     else if (!(keyPtr = env->GetByteArrayElements(aKeyBuffer, 0)))
     {
-        LOGE(" ## initWithSerializedDataJni(): failure - keyPtr JNI allocation OOM");
+        LOGE(" ## deserializeJni(): failure - keyPtr JNI allocation OOM");
     }
     else if (!(pickledPtr = env->GetByteArrayElements(aSerializedDataBuffer, 0)))
     {
-        LOGE(" ## initWithSerializedDataJni(): failure - pickledPtr JNI allocation OOM");
+        LOGE(" ## deserializeJni(): failure - pickledPtr JNI allocation OOM");
     }
     else
     {
         size_t pickledLength = (size_t)env->GetArrayLength(aSerializedDataBuffer);
         size_t keyLength = (size_t)env->GetArrayLength(aKeyBuffer);
-        LOGD(" ## initWithSerializedDataJni(): pickledLength=%lu keyLength=%lu",static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength));
-        LOGD(" ## initWithSerializedDataJni(): key=%s",(char const *)keyPtr);
-        LOGD(" ## initWithSerializedDataJni(): pickled=%s",(char const *)pickledPtr);
+        LOGD(" ## deserializeJni(): pickledLength=%lu keyLength=%lu",static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength));
+        LOGD(" ## deserializeJni(): key=%s",(char const *)keyPtr);
+        LOGD(" ## deserializeJni(): pickled=%s",(char const *)pickledPtr);
 
         size_t result = olm_unpickle_outbound_group_session(sessionPtr,
                                                             (void const *)keyPtr,
@@ -504,12 +504,12 @@ JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(initWithSerializedDataJni)
         if (result == olm_error())
         {
             const char *errorMsgPtr = olm_outbound_group_session_last_error(sessionPtr);
-            LOGE(" ## initWithSerializedDataJni(): failure - olm_unpickle_outbound_group_session() Msg=%s",errorMsgPtr);
+            LOGE(" ## deserializeJni(): failure - olm_unpickle_outbound_group_session() Msg=%s",errorMsgPtr);
             errorMessageRetValue = env->NewStringUTF(errorMsgPtr);
         }
         else
         {
-            LOGD(" ## initWithSerializedDataJni(): success - result=%lu ", static_cast<long unsigned int>(result));
+            LOGD(" ## deserializeJni(): success - result=%lu ", static_cast<long unsigned int>(result));
         }
     }
 
diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_outbound_group_session.h b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_outbound_group_session.h
index 37f0ea6..f954bef 100644
--- a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_outbound_group_session.h
+++ b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_outbound_group_session.h
@@ -40,8 +40,8 @@ JNIEXPORT jbyteArray OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(sessionKeyJni)(JNIEnv *
 JNIEXPORT jbyteArray OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(encryptMessageJni)(JNIEnv *env, jobject thiz, jbyteArray aClearMsgBuffer, jobject aErrorMsg);
 
 // serialization
-JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env, jobject thiz, jbyteArray aKey, jobject aErrorMsg);
-JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(initWithSerializedDataJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedData, jbyteArray aKey);
+JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(serializeJni)(JNIEnv *env, jobject thiz, jbyteArray aKey, jobject aErrorMsg);
+JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(deserializeJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedData, jbyteArray aKey);
 
 #ifdef __cplusplus
 }
diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_session.cpp b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_session.cpp
index 3731d14..4a1717a 100644
--- a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_session.cpp
+++ b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_session.cpp
@@ -780,7 +780,7 @@ JNIEXPORT jbyteArray OLM_SESSION_FUNC_DEF(getSessionIdentifierJni)(JNIEnv *env,
 * @param[out] aErrorMsg error message set if operation failed
 * @return a base64 string if operation succeed, null otherwise
 **/
-JNIEXPORT jstring OLM_SESSION_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env, jobject thiz, jbyteArray aKeyBuffer, jobject aErrorMsg)
+JNIEXPORT jstring OLM_SESSION_FUNC_DEF(serializeJni)(JNIEnv *env, jobject thiz, jbyteArray aKeyBuffer, jobject aErrorMsg)
 {
     jstring pickledDataRetValue = 0;
     jclass errorMsgJClass = 0;
@@ -789,44 +789,44 @@ JNIEXPORT jstring OLM_SESSION_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env, job
     jbyte* keyPtr = NULL;
     OlmSession* sessionPtr = NULL;
 
-    LOGD("## serializeDataWithKeyJni(): IN");
+    LOGD("## serializeJni(): IN");
 
     if (!(sessionPtr = (OlmSession*)getSessionInstanceId(env,thiz)))
     {
-        LOGE(" ## serializeDataWithKeyJni(): failure - invalid session ptr");
+        LOGE(" ## serializeJni(): failure - invalid session ptr");
     }
     else if (!aKeyBuffer)
     {
-        LOGE(" ## serializeDataWithKeyJni(): failure - invalid key");
+        LOGE(" ## serializeJni(): failure - invalid key");
     }
     else if (!aErrorMsg)
     {
-        LOGE(" ## serializeDataWithKeyJni(): failure - invalid error object");
+        LOGE(" ## serializeJni(): failure - invalid error object");
     }
     else if (!(errorMsgJClass = env->GetObjectClass(aErrorMsg)))
     {
-        LOGE(" ## serializeDataWithKeyJni(): failure - unable to get error class");
+        LOGE(" ## serializeJni(): failure - unable to get error class");
     }
     else if (!(errorMsgMethodId = env->GetMethodID(errorMsgJClass, "append", "(Ljava/lang/String;)Ljava/lang/StringBuffer;")))
     {
-        LOGE(" ## serializeDataWithKeyJni(): failure - unable to get error method ID");
+        LOGE(" ## serializeJni(): failure - unable to get error method ID");
     }
     else if (!(keyPtr = env->GetByteArrayElements(aKeyBuffer, 0)))
     {
-        LOGE(" ## serializeDataWithKeyJni(): failure - keyPtr JNI allocation OOM");
+        LOGE(" ## serializeJni(): failure - keyPtr JNI allocation OOM");
     }
     else
     {
         size_t pickledLength = olm_pickle_session_length(sessionPtr);
         size_t keyLength = (size_t)env->GetArrayLength(aKeyBuffer);
-        LOGD(" ## serializeDataWithKeyJni(): pickledLength=%lu keyLength=%lu",static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength));
-        LOGD(" ## serializeDataWithKeyJni(): key=%s",(char const *)keyPtr);
+        LOGD(" ## serializeJni(): pickledLength=%lu keyLength=%lu",static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength));
+        LOGD(" ## serializeJni(): key=%s",(char const *)keyPtr);
 
         void *pickledPtr = malloc((pickledLength+1)*sizeof(uint8_t));
 
         if (!pickledPtr)
         {
-            LOGE(" ## serializeDataWithKeyJni(): failure - pickledPtr buffer OOM");
+            LOGE(" ## serializeJni(): failure - pickledPtr buffer OOM");
         }
         else
         {
@@ -838,7 +838,7 @@ JNIEXPORT jstring OLM_SESSION_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env, job
             if (result == olm_error())
             {
                 const char *errorMsgPtr = olm_session_last_error(sessionPtr);
-                LOGE(" ## serializeDataWithKeyJni(): failure - olm_pickle_session() Msg=%s",errorMsgPtr);
+                LOGE(" ## serializeJni(): failure - olm_pickle_session() Msg=%s",errorMsgPtr);
 
                 if ((errorJstring = env->NewStringUTF(errorMsgPtr)))
                 {
@@ -850,7 +850,7 @@ JNIEXPORT jstring OLM_SESSION_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env, job
                 // build success output
                 (static_cast<char*>(pickledPtr))[pickledLength] = static_cast<char>('\0');
                 pickledDataRetValue = env->NewStringUTF((const char*)pickledPtr);
-                LOGD(" ## serializeDataWithKeyJni(): success - result=%lu pickled=%s", static_cast<long unsigned int>(result), static_cast<char*>(pickledPtr));
+                LOGD(" ## serializeJni(): success - result=%lu pickled=%s", static_cast<long unsigned int>(result), static_cast<char*>(pickledPtr));
             }
 
             free(pickledPtr);
@@ -867,42 +867,42 @@ JNIEXPORT jstring OLM_SESSION_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env, job
 }
 
 
-JNIEXPORT jstring OLM_SESSION_FUNC_DEF(initWithSerializedDataJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedDataBuffer, jbyteArray aKeyBuffer)
+JNIEXPORT jstring OLM_SESSION_FUNC_DEF(deserializeJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedDataBuffer, jbyteArray aKeyBuffer)
 {
     OlmSession* sessionPtr = NULL;
     jstring errorMessageRetValue = 0;
     jbyte* keyPtr = NULL;
     jbyte* pickledPtr = NULL;
 
-    LOGD("## initWithSerializedDataJni(): IN");
+    LOGD("## deserializeJni(): IN");
 
     if (!(sessionPtr = (OlmSession*)getSessionInstanceId(env,thiz)))
     {
-        LOGE(" ## initWithSerializedDataJni(): failure - session failure OOM");
+        LOGE(" ## deserializeJni(): failure - session failure OOM");
     }
     else if (!aKeyBuffer)
     {
-        LOGE(" ## initWithSerializedDataJni(): failure - invalid key");
+        LOGE(" ## deserializeJni(): failure - invalid key");
     }
     else if (!aSerializedDataBuffer)
     {
-        LOGE(" ## initWithSerializedDataJni(): failure - serialized data");
+        LOGE(" ## deserializeJni(): failure - serialized data");
     }
     else if (!(keyPtr = env->GetByteArrayElements(aKeyBuffer, 0)))
     {
-        LOGE(" ## initWithSerializedDataJni(): failure - keyPtr JNI allocation OOM");
+        LOGE(" ## deserializeJni(): failure - keyPtr JNI allocation OOM");
     }
     else if (!(pickledPtr = env->GetByteArrayElements(aSerializedDataBuffer, 0)))
     {
-        LOGE(" ## initWithSerializedDataJni(): failure - pickledPtr JNI allocation OOM");
+        LOGE(" ## deserializeJni(): failure - pickledPtr JNI allocation OOM");
     }
     else
     {
         size_t pickledLength = (size_t)env->GetArrayLength(aSerializedDataBuffer);
         size_t keyLength = (size_t)env->GetArrayLength(aKeyBuffer);
-        LOGD(" ## initWithSerializedDataJni(): pickledLength=%lu keyLength=%lu",static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength));
-        LOGD(" ## initWithSerializedDataJni(): key=%s",(char const *)keyPtr);
-        LOGD(" ## initWithSerializedDataJni(): pickled=%s",(char const *)pickledPtr);
+        LOGD(" ## deserializeJni(): pickledLength=%lu keyLength=%lu",static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength));
+        LOGD(" ## deserializeJni(): key=%s",(char const *)keyPtr);
+        LOGD(" ## deserializeJni(): pickled=%s",(char const *)pickledPtr);
 
         size_t result = olm_unpickle_session(sessionPtr,
                                              (void const *)keyPtr,
@@ -912,14 +912,13 @@ JNIEXPORT jstring OLM_SESSION_FUNC_DEF(initWithSerializedDataJni)(JNIEnv *env, j
         if (result == olm_error())
         {
             const char *errorMsgPtr = olm_session_last_error(sessionPtr);
-            LOGE(" ## initWithSerializedDataJni(): failure - olm_unpickle_account() Msg=%s",errorMsgPtr);
+            LOGE(" ## deserializeJni(): failure - olm_unpickle_account() Msg=%s",errorMsgPtr);
             errorMessageRetValue = env->NewStringUTF(errorMsgPtr);
         }
         else
         {
-            LOGD(" ## initWithSerializedDataJni(): success - result=%lu ", static_cast<long unsigned int>(result));
+            LOGD(" ## initJni(): success - result=%lu ", static_cast<long unsigned int>(result));
         }
-
     }
 
     // free alloc
diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_session.h b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_session.h
index 9ce12d4..95b421b 100644
--- a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_session.h
+++ b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_session.h
@@ -50,8 +50,8 @@ JNIEXPORT jbyteArray OLM_SESSION_FUNC_DEF(decryptMessageJni)(JNIEnv *env, jobjec
 JNIEXPORT jbyteArray OLM_SESSION_FUNC_DEF(getSessionIdentifierJni)(JNIEnv *env, jobject thiz);
 
 // serialization
-JNIEXPORT jstring OLM_SESSION_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env, jobject thiz, jbyteArray aKey, jobject aErrorMsg);
-JNIEXPORT jstring OLM_SESSION_FUNC_DEF(initWithSerializedDataJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedData, jbyteArray aKey);
+JNIEXPORT jstring OLM_SESSION_FUNC_DEF(serializeJni)(JNIEnv *env, jobject thiz, jbyteArray aKey, jobject aErrorMsg);
+JNIEXPORT jstring OLM_SESSION_FUNC_DEF(deserializeJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedData, jbyteArray aKey);
 
 #ifdef __cplusplus
 }