media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/unit/MediaPlayerMetadataParserTest.java - platform/frameworks/base - Gitiles

 /*
  * Copyright (C) 2009 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.mediaframeworktest.unit;
 import android.media.Metadata;
 import android.os.Parcel;
 import android.test.AndroidTestCase;
 import android.test.suitebuilder.annotation.SmallTest;
 import android.util.Log;

 import java.util.Calendar;
 import java.util.Date;

 /*
  * Check the Java layer that parses serialized metadata in Parcel
  * works as expected.
  *
  */

 public class MediaPlayerMetadataParserTest extends AndroidTestCase {
     private static final String TAG = "MediaPlayerMetadataTest";
     private static final int kMarker = 0x4d455441;  // 'M' 'E' 'T' 'A'
     private static final int kHeaderSize = 8;

     private Metadata mMetadata = null;
     private Parcel mParcel = null;

     @Override
     protected void setUp() throws Exception {
         super.setUp();
         mMetadata = new Metadata();
         mParcel = Parcel.obtain();

         resetParcel();
     }

     // Check parsing of the parcel fails. Make sure the parser rewind
     // the parcel properly.
     private void assertParseFail() throws Exception {
         mParcel.setDataPosition(0);
         assertFalse(mMetadata.parse(mParcel));
         assertEquals(0, mParcel.dataPosition());
     }

     // Check parsing of the parcel is successful.
     private void assertParse() throws Exception {
         mParcel.setDataPosition(0);
         assertTrue(mMetadata.parse(mParcel));
     }

     // Write the number of bytes from the start of the parcel to the
     // current position at the beginning of the parcel (offset 0).
     private void adjustSize() {
         adjustSize(0);
     }

     // Write the number of bytes from the offset to the current
     // position at position pointed by offset.
     private void adjustSize(int offset) {
         final int pos = mParcel.dataPosition();

         mParcel.setDataPosition(offset);
         mParcel.writeInt(pos - offset);
         mParcel.setDataPosition(pos);
     }

     // Rewind the parcel and insert the header.
     private void resetParcel() {
         mParcel.setDataPosition(0);
         // Most tests will use a properly formed parcel with a size
         // and the meta marker so we add them by default.
         mParcel.writeInt(-1);  // Placeholder for the size
         mParcel.writeInt(kMarker);
     }

     // ----------------------------------------------------------------------
     // START OF THE TESTS


     // There should be at least 8 bytes in the parcel, 4 for the size
     // and 4 for the 'M' 'E' 'T' 'A' marker.
     @SmallTest
     public void testMissingSizeAndMarker() throws Exception {
         for (int i = 0; i < kHeaderSize; ++i) {
             mParcel.setDataPosition(0);
             mParcel.setDataSize(i);

             assertEquals(i, mParcel.dataAvail());
             assertParseFail();
         }
     }

     // There should be at least 'size' bytes in the parcel.
     @SmallTest
     public void testMissingData() throws Exception {
         final int size = 20;

         mParcel.writeInt(size);
         mParcel.setDataSize(size - 1);
         assertParseFail();
     }

     // Empty parcel is fine
     @SmallTest
     public void testEmptyIsOk() throws Exception {
         adjustSize();
         assertParse();
     }

     // ----------------------------------------------------------------------
     // RECORDS
     // ----------------------------------------------------------------------

     // A record header should be at least 12 bytes long
     @SmallTest
     public void testRecordMissingId() throws Exception {
         mParcel.writeInt(13); // record length
         // misses metadata id and metadata type.
         adjustSize();
         assertParseFail();
     }

     @SmallTest
     public void testRecordMissingType() throws Exception {
         mParcel.writeInt(13); // record length lies
         mParcel.writeInt(Metadata.TITLE);
         // misses metadata type
         adjustSize();
         assertParseFail();
     }

     @SmallTest
     public void testRecordWithZeroPayload() throws Exception {
         mParcel.writeInt(0);
         adjustSize();
         assertParseFail();
     }

     // A record cannot be empty.
     @SmallTest
     public void testRecordMissingPayload() throws Exception {
         mParcel.writeInt(12);
         mParcel.writeInt(Metadata.TITLE);
         mParcel.writeInt(Metadata.STRING_VAL);
         // misses payload
         adjustSize();
         assertParseFail();
     }

     // Check records can be found.
     @SmallTest
     public void testRecordsFound() throws Exception {
         writeStringRecord(Metadata.TITLE, "a title");
         writeStringRecord(Metadata.GENRE, "comedy");
         writeStringRecord(Metadata.firstCustomId(), "custom");
         adjustSize();
         assertParse();
         assertTrue(mMetadata.has(Metadata.TITLE));
         assertTrue(mMetadata.has(Metadata.GENRE));
         assertTrue(mMetadata.has(Metadata.firstCustomId()));
         assertFalse(mMetadata.has(Metadata.DRM_CRIPPLED));
         assertEquals(3, mMetadata.keySet().size());
     }

     // Detects bad metadata type
     @SmallTest
     public void testBadMetadataType() throws Exception {
         final int start = mParcel.dataPosition();
         mParcel.writeInt(-1);  // Placeholder for the length
         mParcel.writeInt(Metadata.TITLE);
         mParcel.writeInt(0);  // Invalid type.
         mParcel.writeString("dummy");
         adjustSize(start);

         adjustSize();
         assertParseFail();
     }

     // Check a Metadata instance can be reused, i.e the parse method
     // wipes out the existing states/keys.
     @SmallTest
     public void testParseClearState() throws Exception {
         writeStringRecord(Metadata.TITLE, "a title");
         writeStringRecord(Metadata.GENRE, "comedy");
         writeStringRecord(Metadata.firstCustomId(), "custom");
         adjustSize();
         assertParse();

         resetParcel();
         writeStringRecord(Metadata.MIME_TYPE, "audio/mpg");
         adjustSize();
         assertParse();

         // Only the mime type metadata should be present.
         assertEquals(1, mMetadata.keySet().size());
         assertTrue(mMetadata.has(Metadata.MIME_TYPE));

         assertFalse(mMetadata.has(Metadata.TITLE));
         assertFalse(mMetadata.has(Metadata.GENRE));
         assertFalse(mMetadata.has(Metadata.firstCustomId()));
     }

     // ----------------------------------------------------------------------
     // GETTERS
     // ----------------------------------------------------------------------

     // getString
     @SmallTest
     public void testGetString() throws Exception {
         writeStringRecord(Metadata.TITLE, "a title");
         writeStringRecord(Metadata.GENRE, "comedy");
         adjustSize();
         assertParse();

         assertEquals("a title", mMetadata.getString(Metadata.TITLE));
         assertEquals("comedy", mMetadata.getString(Metadata.GENRE));
     }

     // get an empty string.
     @SmallTest
     public void testGetEmptyString() throws Exception {
         writeStringRecord(Metadata.TITLE, "");
         adjustSize();
         assertParse();

         assertEquals("", mMetadata.getString(Metadata.TITLE));
     }

     // get a string when a NULL value was in the parcel
     @SmallTest
     public void testGetNullString() throws Exception {
         writeStringRecord(Metadata.TITLE, null);
         adjustSize();
         assertParse();

         assertEquals(null, mMetadata.getString(Metadata.TITLE));
     }

     // get a string when an integer is actually present
     @SmallTest
     public void testWrongType() throws Exception {
         writeIntRecord(Metadata.DURATION, 5);
         adjustSize();
         assertParse();

         try {
             mMetadata.getString(Metadata.DURATION);
         } catch (IllegalStateException ise) {
             return;
         }
         fail("Exception was not thrown");
     }

     // getInt
     @SmallTest
     public void testGetInt() throws Exception {
         writeIntRecord(Metadata.CD_TRACK_NUM, 1);
         adjustSize();
         assertParse();

         assertEquals(1, mMetadata.getInt(Metadata.CD_TRACK_NUM));
     }

     // getBoolean
     @SmallTest
     public void testGetBoolean() throws Exception {
         writeBooleanRecord(Metadata.PAUSE_AVAILABLE, true);
         writeBooleanRecord(Metadata.SEEK_AVAILABLE, true);
         writeBooleanRecord(Metadata.SEEK_BACKWARD_AVAILABLE, true);
         writeBooleanRecord(Metadata.SEEK_FORWARD_AVAILABLE, true);
         adjustSize();
         assertParse();

         assertEquals(true, mMetadata.getBoolean(Metadata.PAUSE_AVAILABLE));
         assertEquals(true, mMetadata.getBoolean(Metadata.SEEK_AVAILABLE));
         assertEquals(true, mMetadata.getBoolean(Metadata.SEEK_BACKWARD_AVAILABLE));
         assertEquals(true, mMetadata.getBoolean(Metadata.SEEK_FORWARD_AVAILABLE));
     }

     // getLong
     @SmallTest
     public void testGetLong() throws Exception {
         writeLongRecord(Metadata.DURATION, 1L);
         adjustSize();
         assertParse();

         assertEquals(1L, mMetadata.getLong(Metadata.DURATION));
     }

     // getDouble
     @SmallTest
     public void testGetDouble() throws Exception {
         writeDoubleRecord(Metadata.VIDEO_FRAME_RATE, 29.97);
         adjustSize();
         assertParse();

         assertEquals(29.97, mMetadata.getDouble(Metadata.VIDEO_FRAME_RATE));
     }

     // getByteArray
     @SmallTest
     public void testGetByteArray() throws Exception {
         byte data[] = new byte[]{1,2,3,4,5};

         writeByteArrayRecord(Metadata.ALBUM_ART, data);
         adjustSize();
         assertParse();

         byte res[] = mMetadata.getByteArray(Metadata.ALBUM_ART);
         for (int i = 0; i < data.length; ++i) {
             assertEquals(data[i], res[i]);
         }
     }

     // getDate
     @SmallTest
     public void testGetDate() throws Exception {
         writeDateRecord(Metadata.DATE, 0, "PST");
         adjustSize();
         assertParse();

         assertEquals(new Date(0), mMetadata.getDate(Metadata.DATE));
     }

     // ----------------------------------------------------------------------
     // HELPERS TO APPEND RECORDS
     // ----------------------------------------------------------------------

     // Insert a string record at the current position.
     private void writeStringRecord(int metadataId, String val) {
         final int start = mParcel.dataPosition();
         mParcel.writeInt(-1);  // Placeholder for the length
         mParcel.writeInt(metadataId);
         mParcel.writeInt(Metadata.STRING_VAL);
         mParcel.writeString(val);
         adjustSize(start);
     }

     // Insert an int record at the current position.
     private void writeIntRecord(int metadataId, int val) {
         final int start = mParcel.dataPosition();
         mParcel.writeInt(-1);  // Placeholder for the length
         mParcel.writeInt(metadataId);
         mParcel.writeInt(Metadata.INTEGER_VAL);
         mParcel.writeInt(val);
         adjustSize(start);
     }

     // Insert a boolean record at the current position.
     private void writeBooleanRecord(int metadataId, boolean val) {
         final int start = mParcel.dataPosition();
         mParcel.writeInt(-1);  // Placeholder for the length
         mParcel.writeInt(metadataId);
         mParcel.writeInt(Metadata.BOOLEAN_VAL);
         mParcel.writeInt(val ? 1 : 0);
         adjustSize(start);
     }

     // Insert a Long record at the current position.
     private void writeLongRecord(int metadataId, long val) {
         final int start = mParcel.dataPosition();
         mParcel.writeInt(-1);  // Placeholder for the length
         mParcel.writeInt(metadataId);
         mParcel.writeInt(Metadata.LONG_VAL);
         mParcel.writeLong(val);
         adjustSize(start);
     }

     // Insert a Double record at the current position.
     private void writeDoubleRecord(int metadataId, double val) {
         final int start = mParcel.dataPosition();
         mParcel.writeInt(-1);  // Placeholder for the length
         mParcel.writeInt(metadataId);
         mParcel.writeInt(Metadata.DOUBLE_VAL);
         mParcel.writeDouble(val);
         adjustSize(start);
     }

     // Insert a ByteArray record at the current position.
     private void writeByteArrayRecord(int metadataId, byte[] val) {
         final int start = mParcel.dataPosition();
         mParcel.writeInt(-1);  // Placeholder for the length
         mParcel.writeInt(metadataId);
         mParcel.writeInt(Metadata.BYTE_ARRAY_VAL);
         mParcel.writeByteArray(val);
         adjustSize(start);
     }

     // Insert a Date record at the current position.
     private void writeDateRecord(int metadataId, long time, String tz) {
         final int start = mParcel.dataPosition();
         mParcel.writeInt(-1);  // Placeholder for the length
         mParcel.writeInt(metadataId);
         mParcel.writeInt(Metadata.DATE_VAL);
         mParcel.writeLong(time);
         mParcel.writeString(tz);
         adjustSize(start);
     }
 }
	/*
	* Copyright (C) 2009 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.mediaframeworktest.unit;
	import android.media.Metadata;
	import android.os.Parcel;
	import android.test.AndroidTestCase;
	import android.test.suitebuilder.annotation.SmallTest;
	import android.util.Log;

	import java.util.Calendar;
	import java.util.Date;

	/*
	* Check the Java layer that parses serialized metadata in Parcel
	* works as expected.
	*
	*/

	public class MediaPlayerMetadataParserTest extends AndroidTestCase {
	private static final String TAG = "MediaPlayerMetadataTest";
	private static final int kMarker = 0x4d455441; // 'M' 'E' 'T' 'A'
	private static final int kHeaderSize = 8;

	private Metadata mMetadata = null;
	private Parcel mParcel = null;

	@Override
	protected void setUp() throws Exception {
	super.setUp();
	mMetadata = new Metadata();
	mParcel = Parcel.obtain();

	resetParcel();
	}

	// Check parsing of the parcel fails. Make sure the parser rewind
	// the parcel properly.
	private void assertParseFail() throws Exception {
	mParcel.setDataPosition(0);
	assertFalse(mMetadata.parse(mParcel));
	assertEquals(0, mParcel.dataPosition());
	}

	// Check parsing of the parcel is successful.
	private void assertParse() throws Exception {
	mParcel.setDataPosition(0);
	assertTrue(mMetadata.parse(mParcel));
	}

	// Write the number of bytes from the start of the parcel to the
	// current position at the beginning of the parcel (offset 0).
	private void adjustSize() {
	adjustSize(0);
	}

	// Write the number of bytes from the offset to the current
	// position at position pointed by offset.
	private void adjustSize(int offset) {
	final int pos = mParcel.dataPosition();

	mParcel.setDataPosition(offset);
	mParcel.writeInt(pos - offset);
	mParcel.setDataPosition(pos);
	}

	// Rewind the parcel and insert the header.
	private void resetParcel() {
	mParcel.setDataPosition(0);
	// Most tests will use a properly formed parcel with a size
	// and the meta marker so we add them by default.
	mParcel.writeInt(-1); // Placeholder for the size
	mParcel.writeInt(kMarker);
	}

	// ----------------------------------------------------------------------
	// START OF THE TESTS


	// There should be at least 8 bytes in the parcel, 4 for the size
	// and 4 for the 'M' 'E' 'T' 'A' marker.
	@SmallTest
	public void testMissingSizeAndMarker() throws Exception {
	for (int i = 0; i < kHeaderSize; ++i) {
	mParcel.setDataPosition(0);
	mParcel.setDataSize(i);

	assertEquals(i, mParcel.dataAvail());
	assertParseFail();
	}
	}

	// There should be at least 'size' bytes in the parcel.
	@SmallTest
	public void testMissingData() throws Exception {
	final int size = 20;

	mParcel.writeInt(size);
	mParcel.setDataSize(size - 1);
	assertParseFail();
	}

	// Empty parcel is fine
	@SmallTest
	public void testEmptyIsOk() throws Exception {
	adjustSize();
	assertParse();
	}

	// ----------------------------------------------------------------------
	// RECORDS
	// ----------------------------------------------------------------------

	// A record header should be at least 12 bytes long
	@SmallTest
	public void testRecordMissingId() throws Exception {
	mParcel.writeInt(13); // record length
	// misses metadata id and metadata type.
	adjustSize();
	assertParseFail();
	}

	@SmallTest
	public void testRecordMissingType() throws Exception {
	mParcel.writeInt(13); // record length lies
	mParcel.writeInt(Metadata.TITLE);
	// misses metadata type
	adjustSize();
	assertParseFail();
	}

	@SmallTest
	public void testRecordWithZeroPayload() throws Exception {
	mParcel.writeInt(0);
	adjustSize();
	assertParseFail();
	}

	// A record cannot be empty.
	@SmallTest
	public void testRecordMissingPayload() throws Exception {
	mParcel.writeInt(12);
	mParcel.writeInt(Metadata.TITLE);
	mParcel.writeInt(Metadata.STRING_VAL);
	// misses payload
	adjustSize();
	assertParseFail();
	}

	// Check records can be found.
	@SmallTest
	public void testRecordsFound() throws Exception {
	writeStringRecord(Metadata.TITLE, "a title");
	writeStringRecord(Metadata.GENRE, "comedy");
	writeStringRecord(Metadata.firstCustomId(), "custom");
	adjustSize();
	assertParse();
	assertTrue(mMetadata.has(Metadata.TITLE));
	assertTrue(mMetadata.has(Metadata.GENRE));
	assertTrue(mMetadata.has(Metadata.firstCustomId()));
	assertFalse(mMetadata.has(Metadata.DRM_CRIPPLED));
	assertEquals(3, mMetadata.keySet().size());
	}

	// Detects bad metadata type
	@SmallTest
	public void testBadMetadataType() throws Exception {
	final int start = mParcel.dataPosition();
	mParcel.writeInt(-1); // Placeholder for the length
	mParcel.writeInt(Metadata.TITLE);
	mParcel.writeInt(0); // Invalid type.
	mParcel.writeString("dummy");
	adjustSize(start);

	adjustSize();
	assertParseFail();
	}

	// Check a Metadata instance can be reused, i.e the parse method
	// wipes out the existing states/keys.
	@SmallTest
	public void testParseClearState() throws Exception {
	writeStringRecord(Metadata.TITLE, "a title");
	writeStringRecord(Metadata.GENRE, "comedy");
	writeStringRecord(Metadata.firstCustomId(), "custom");
	adjustSize();
	assertParse();

	resetParcel();
	writeStringRecord(Metadata.MIME_TYPE, "audio/mpg");
	adjustSize();
	assertParse();

	// Only the mime type metadata should be present.
	assertEquals(1, mMetadata.keySet().size());
	assertTrue(mMetadata.has(Metadata.MIME_TYPE));

	assertFalse(mMetadata.has(Metadata.TITLE));
	assertFalse(mMetadata.has(Metadata.GENRE));
	assertFalse(mMetadata.has(Metadata.firstCustomId()));
	}

	// ----------------------------------------------------------------------
	// GETTERS
	// ----------------------------------------------------------------------

	// getString
	@SmallTest
	public void testGetString() throws Exception {
	writeStringRecord(Metadata.TITLE, "a title");
	writeStringRecord(Metadata.GENRE, "comedy");
	adjustSize();
	assertParse();

	assertEquals("a title", mMetadata.getString(Metadata.TITLE));
	assertEquals("comedy", mMetadata.getString(Metadata.GENRE));
	}

	// get an empty string.
	@SmallTest
	public void testGetEmptyString() throws Exception {
	writeStringRecord(Metadata.TITLE, "");
	adjustSize();
	assertParse();

	assertEquals("", mMetadata.getString(Metadata.TITLE));
	}

	// get a string when a NULL value was in the parcel
	@SmallTest
	public void testGetNullString() throws Exception {
	writeStringRecord(Metadata.TITLE, null);
	adjustSize();
	assertParse();

	assertEquals(null, mMetadata.getString(Metadata.TITLE));
	}

	// get a string when an integer is actually present
	@SmallTest
	public void testWrongType() throws Exception {
	writeIntRecord(Metadata.DURATION, 5);
	adjustSize();
	assertParse();

	try {
	mMetadata.getString(Metadata.DURATION);
	} catch (IllegalStateException ise) {
	return;
	}
	fail("Exception was not thrown");
	}

	// getInt
	@SmallTest
	public void testGetInt() throws Exception {
	writeIntRecord(Metadata.CD_TRACK_NUM, 1);
	adjustSize();
	assertParse();

	assertEquals(1, mMetadata.getInt(Metadata.CD_TRACK_NUM));
	}

	// getBoolean
	@SmallTest
	public void testGetBoolean() throws Exception {
	writeBooleanRecord(Metadata.PAUSE_AVAILABLE, true);
	writeBooleanRecord(Metadata.SEEK_AVAILABLE, true);
	writeBooleanRecord(Metadata.SEEK_BACKWARD_AVAILABLE, true);
	writeBooleanRecord(Metadata.SEEK_FORWARD_AVAILABLE, true);
	adjustSize();
	assertParse();

	assertEquals(true, mMetadata.getBoolean(Metadata.PAUSE_AVAILABLE));
	assertEquals(true, mMetadata.getBoolean(Metadata.SEEK_AVAILABLE));
	assertEquals(true, mMetadata.getBoolean(Metadata.SEEK_BACKWARD_AVAILABLE));
	assertEquals(true, mMetadata.getBoolean(Metadata.SEEK_FORWARD_AVAILABLE));
	}

	// getLong
	@SmallTest
	public void testGetLong() throws Exception {
	writeLongRecord(Metadata.DURATION, 1L);
	adjustSize();
	assertParse();

	assertEquals(1L, mMetadata.getLong(Metadata.DURATION));
	}

	// getDouble
	@SmallTest
	public void testGetDouble() throws Exception {
	writeDoubleRecord(Metadata.VIDEO_FRAME_RATE, 29.97);
	adjustSize();
	assertParse();

	assertEquals(29.97, mMetadata.getDouble(Metadata.VIDEO_FRAME_RATE));
	}

	// getByteArray
	@SmallTest
	public void testGetByteArray() throws Exception {
	byte data[] = new byte[]{1,2,3,4,5};

	writeByteArrayRecord(Metadata.ALBUM_ART, data);
	adjustSize();
	assertParse();

	byte res[] = mMetadata.getByteArray(Metadata.ALBUM_ART);
	for (int i = 0; i < data.length; ++i) {
	assertEquals(data[i], res[i]);
	}
	}

	// getDate
	@SmallTest
	public void testGetDate() throws Exception {
	writeDateRecord(Metadata.DATE, 0, "PST");
	adjustSize();
	assertParse();

	assertEquals(new Date(0), mMetadata.getDate(Metadata.DATE));
	}

	// ----------------------------------------------------------------------
	// HELPERS TO APPEND RECORDS
	// ----------------------------------------------------------------------

	// Insert a string record at the current position.
	private void writeStringRecord(int metadataId, String val) {
	final int start = mParcel.dataPosition();
	mParcel.writeInt(-1); // Placeholder for the length
	mParcel.writeInt(metadataId);
	mParcel.writeInt(Metadata.STRING_VAL);
	mParcel.writeString(val);
	adjustSize(start);
	}

	// Insert an int record at the current position.
	private void writeIntRecord(int metadataId, int val) {
	final int start = mParcel.dataPosition();
	mParcel.writeInt(-1); // Placeholder for the length
	mParcel.writeInt(metadataId);
	mParcel.writeInt(Metadata.INTEGER_VAL);
	mParcel.writeInt(val);
	adjustSize(start);
	}

	// Insert a boolean record at the current position.
	private void writeBooleanRecord(int metadataId, boolean val) {
	final int start = mParcel.dataPosition();
	mParcel.writeInt(-1); // Placeholder for the length
	mParcel.writeInt(metadataId);
	mParcel.writeInt(Metadata.BOOLEAN_VAL);
	mParcel.writeInt(val ? 1 : 0);
	adjustSize(start);
	}

	// Insert a Long record at the current position.
	private void writeLongRecord(int metadataId, long val) {
	final int start = mParcel.dataPosition();
	mParcel.writeInt(-1); // Placeholder for the length
	mParcel.writeInt(metadataId);
	mParcel.writeInt(Metadata.LONG_VAL);
	mParcel.writeLong(val);
	adjustSize(start);
	}

	// Insert a Double record at the current position.
	private void writeDoubleRecord(int metadataId, double val) {
	final int start = mParcel.dataPosition();
	mParcel.writeInt(-1); // Placeholder for the length
	mParcel.writeInt(metadataId);
	mParcel.writeInt(Metadata.DOUBLE_VAL);
	mParcel.writeDouble(val);
	adjustSize(start);
	}

	// Insert a ByteArray record at the current position.
	private void writeByteArrayRecord(int metadataId, byte[] val) {
	final int start = mParcel.dataPosition();
	mParcel.writeInt(-1); // Placeholder for the length
	mParcel.writeInt(metadataId);
	mParcel.writeInt(Metadata.BYTE_ARRAY_VAL);
	mParcel.writeByteArray(val);
	adjustSize(start);
	}

	// Insert a Date record at the current position.
	private void writeDateRecord(int metadataId, long time, String tz) {
	final int start = mParcel.dataPosition();
	mParcel.writeInt(-1); // Placeholder for the length
	mParcel.writeInt(metadataId);
	mParcel.writeInt(Metadata.DATE_VAL);
	mParcel.writeLong(time);
	mParcel.writeString(tz);
	adjustSize(start);
	}
	}