mtp/MtpProperty.cpp

/*
 * Copyright (C) 2010 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.
 *
 * Copyright (C) 2014 TeamWin - bigbiff and Dees_Troy mtp database conversion to C++
 */

#include "MtpDataPacket.h"
#include "MtpDebug.h"
#include "MtpProperty.h"
#include "MtpStringBuffer.h"
#include "MtpUtils.h"

MtpProperty::MtpProperty()
	:	mCode(0),
		mType(0),
		mWriteable(false),
		mDefaultArrayLength(0),
		mDefaultArrayValues(NULL),
		mCurrentArrayLength(0),
		mCurrentArrayValues(NULL),
		mGroupCode(0),
		mFormFlag(kFormNone),
		mEnumLength(0),
		mEnumValues(NULL)
{
	memset(&mDefaultValue, 0, sizeof(mDefaultValue));
	memset(&mCurrentValue, 0, sizeof(mCurrentValue));
	memset(&mMinimumValue, 0, sizeof(mMinimumValue));
	memset(&mMaximumValue, 0, sizeof(mMaximumValue));
}

MtpProperty::MtpProperty(MtpPropertyCode propCode,
						 MtpDataType type,
						 bool writeable,
						 int defaultValue)
	:   mCode(propCode),
		mType(type),
		mWriteable(writeable),
		mDefaultArrayLength(0),
		mDefaultArrayValues(NULL),
		mCurrentArrayLength(0),
		mCurrentArrayValues(NULL),
		mGroupCode(0),
		mFormFlag(kFormNone),
		mEnumLength(0),
		mEnumValues(NULL)
{
	memset(&mDefaultValue, 0, sizeof(mDefaultValue));
	memset(&mCurrentValue, 0, sizeof(mCurrentValue));
	memset(&mMinimumValue, 0, sizeof(mMinimumValue));
	memset(&mMaximumValue, 0, sizeof(mMaximumValue));

	if (defaultValue) {
		switch (type) {
			case MTP_TYPE_INT8:
				mDefaultValue.u.i8 = defaultValue;
				break;
			case MTP_TYPE_UINT8:
				mDefaultValue.u.u8 = defaultValue;
				break;
			case MTP_TYPE_INT16:
				mDefaultValue.u.i16 = defaultValue;
				break;
			case MTP_TYPE_UINT16:
				mDefaultValue.u.u16 = defaultValue;
				break;
			case MTP_TYPE_INT32:
				mDefaultValue.u.i32 = defaultValue;
				break;
			case MTP_TYPE_UINT32:
				mDefaultValue.u.u32 = defaultValue;
				break;
			case MTP_TYPE_INT64:
				mDefaultValue.u.i64 = defaultValue;
				break;
			case MTP_TYPE_UINT64:
				mDefaultValue.u.u64 = defaultValue;
				break;
			default:
				MTPE("unknown type %04X in MtpProperty::MtpProperty", type);
		}
	}
}

MtpProperty::~MtpProperty() {
	if (mType == MTP_TYPE_STR) {
		// free all strings
		free(mDefaultValue.str);
		free(mCurrentValue.str);
		free(mMinimumValue.str);
		free(mMaximumValue.str);
		if (mDefaultArrayValues) {
			for (int i = 0; i < mDefaultArrayLength; i++)
				free(mDefaultArrayValues[i].str);
		}
		if (mCurrentArrayValues) {
			for (int i = 0; i < mCurrentArrayLength; i++)
				free(mCurrentArrayValues[i].str);
		}
		if (mEnumValues) {
			for (int i = 0; i < mEnumLength; i++)
				free(mEnumValues[i].str);
		}
	}
	delete[] mDefaultArrayValues;
	delete[] mCurrentArrayValues;
	delete[] mEnumValues;
}

void MtpProperty::read(MtpDataPacket& packet) {
	mCode = packet.getUInt16();
	bool deviceProp = isDeviceProperty();
	mType = packet.getUInt16();
	mWriteable = (packet.getUInt8() == 1);
	switch (mType) {
		case MTP_TYPE_AINT8:
		case MTP_TYPE_AUINT8:
		case MTP_TYPE_AINT16:
		case MTP_TYPE_AUINT16:
		case MTP_TYPE_AINT32:
		case MTP_TYPE_AUINT32:
		case MTP_TYPE_AINT64:
		case MTP_TYPE_AUINT64:
		case MTP_TYPE_AINT128:
		case MTP_TYPE_AUINT128:
			mDefaultArrayValues = readArrayValues(packet, mDefaultArrayLength);
			if (deviceProp)
				mCurrentArrayValues = readArrayValues(packet, mCurrentArrayLength);
			break;
		default:
			readValue(packet, mDefaultValue);
			if (deviceProp)
				readValue(packet, mCurrentValue);
	}
	if (!deviceProp)
		mGroupCode = packet.getUInt32();
	mFormFlag = packet.getUInt8();

	if (mFormFlag == kFormRange) {
			readValue(packet, mMinimumValue);
			readValue(packet, mMaximumValue);
			readValue(packet, mStepSize);
	} else if (mFormFlag == kFormEnum) {
		mEnumLength = packet.getUInt16();
		mEnumValues = new MtpPropertyValue[mEnumLength];
		for (int i = 0; i < mEnumLength; i++)
			readValue(packet, mEnumValues[i]);
	}
}

void MtpProperty::write(MtpDataPacket& packet) {
	bool deviceProp = isDeviceProperty();

	packet.putUInt16(mCode);
	packet.putUInt16(mType);
	packet.putUInt8(mWriteable ? 1 : 0);

	switch (mType) {
		case MTP_TYPE_AINT8:
		case MTP_TYPE_AUINT8:
		case MTP_TYPE_AINT16:
		case MTP_TYPE_AUINT16:
		case MTP_TYPE_AINT32:
		case MTP_TYPE_AUINT32:
		case MTP_TYPE_AINT64:
		case MTP_TYPE_AUINT64:
		case MTP_TYPE_AINT128:
		case MTP_TYPE_AUINT128:
			writeArrayValues(packet, mDefaultArrayValues, mDefaultArrayLength);
			if (deviceProp)
				writeArrayValues(packet, mCurrentArrayValues, mCurrentArrayLength);
			break;
		default:
			writeValue(packet, mDefaultValue);
			if (deviceProp)
				writeValue(packet, mCurrentValue);
	}
	packet.putUInt32(mGroupCode);
	if (!deviceProp)
		packet.putUInt8(mFormFlag);
	if (mFormFlag == kFormRange) {
			writeValue(packet, mMinimumValue);
			writeValue(packet, mMaximumValue);
			writeValue(packet, mStepSize);
	} else if (mFormFlag == kFormEnum) {
		packet.putUInt16(mEnumLength);
		for (int i = 0; i < mEnumLength; i++)
			writeValue(packet, mEnumValues[i]);
	}
}

void MtpProperty::setDefaultValue(const uint16_t* string) {
	free(mDefaultValue.str);
	if (string) {
		MtpStringBuffer buffer(string);
		mDefaultValue.str = strdup(buffer);
	}
	else
		mDefaultValue.str = NULL;
}

void MtpProperty::setCurrentValue(const uint16_t* string) {
	free(mCurrentValue.str);
	if (string) {
		MtpStringBuffer buffer(string);
		mCurrentValue.str = strdup(buffer);
	}
	else
		mCurrentValue.str = NULL;
}

void MtpProperty::setFormRange(int min, int max, int step) {
	mFormFlag = kFormRange;
	switch (mType) {
		case MTP_TYPE_INT8:
			mMinimumValue.u.i8 = min;
			mMaximumValue.u.i8 = max;
			mStepSize.u.i8 = step;
			break;
		case MTP_TYPE_UINT8:
			mMinimumValue.u.u8 = min;
			mMaximumValue.u.u8 = max;
			mStepSize.u.u8 = step;
			break;
		case MTP_TYPE_INT16:
			mMinimumValue.u.i16 = min;
			mMaximumValue.u.i16 = max;
			mStepSize.u.i16 = step;
			break;
		case MTP_TYPE_UINT16:
			mMinimumValue.u.u16 = min;
			mMaximumValue.u.u16 = max;
			mStepSize.u.u16 = step;
			break;
		case MTP_TYPE_INT32:
			mMinimumValue.u.i32 = min;
			mMaximumValue.u.i32 = max;
			mStepSize.u.i32 = step;
			break;
		case MTP_TYPE_UINT32:
			mMinimumValue.u.u32 = min;
			mMaximumValue.u.u32 = max;
			mStepSize.u.u32 = step;
			break;
		case MTP_TYPE_INT64:
			mMinimumValue.u.i64 = min;
			mMaximumValue.u.i64 = max;
			mStepSize.u.i64 = step;
			break;
		case MTP_TYPE_UINT64:
			mMinimumValue.u.u64 = min;
			mMaximumValue.u.u64 = max;
			mStepSize.u.u64 = step;
			break;
		default:
			MTPE("unsupported type for MtpProperty::setRange");
			break;
	}
}

void MtpProperty::setFormEnum(const int* values, int count) {
	 mFormFlag = kFormEnum;
	 delete[] mEnumValues;
	 mEnumValues = new MtpPropertyValue[count];
	 mEnumLength = count;

	for (int i = 0; i < count; i++) {
		int value = *values++;
			switch (mType) {
				case MTP_TYPE_INT8:
					mEnumValues[i].u.i8 = value;
					break;
				case MTP_TYPE_UINT8:
					mEnumValues[i].u.u8 = value;
					break;
				case MTP_TYPE_INT16:
					mEnumValues[i].u.i16 = value;
					break;
				case MTP_TYPE_UINT16:
					mEnumValues[i].u.u16 = value;
					break;
				case MTP_TYPE_INT32:
					mEnumValues[i].u.i32 = value;
					break;
				case MTP_TYPE_UINT32:
					mEnumValues[i].u.u32 = value;
					break;
				case MTP_TYPE_INT64:
					mEnumValues[i].u.i64 = value;
					break;
				case MTP_TYPE_UINT64:
					mEnumValues[i].u.u64 = value;
					break;
				default:
					MTPE("unsupported type for MtpProperty::setEnum");
					break;
		}
	}
}

void MtpProperty::setFormDateTime() {
	 mFormFlag = kFormDateTime;
}

void MtpProperty::print() {
	MtpString buffer;
	bool deviceProp = isDeviceProperty();
	if (deviceProp)
		MTPI("	%s (%04X)", MtpDebug::getDevicePropCodeName(mCode), mCode);
	else
		MTPI("	%s (%04X)", MtpDebug::getObjectPropCodeName(mCode), mCode);
	MTPI("	type %04X", mType);
	MTPI("	writeable %s", (mWriteable ? "true" : "false"));
	buffer = "	default value: ";
	print(mDefaultValue, buffer);
	MTPI("%s", (const char *)buffer);
	if (deviceProp) {
		buffer = "	current value: ";
		print(mCurrentValue, buffer);
		MTPI("%s", (const char *)buffer);
	}
	switch (mFormFlag) {
		case kFormNone:
			break;
		case kFormRange:
			buffer = "	Range (";
			print(mMinimumValue, buffer);
			buffer += ", ";
			print(mMaximumValue, buffer);
			buffer += ", ";
			print(mStepSize, buffer);
			buffer += ")";
			MTPI("%s", (const char *)buffer);
			break;
		case kFormEnum:
			buffer = "	Enum { ";
			for (int i = 0; i < mEnumLength; i++) {
				print(mEnumValues[i], buffer);
				buffer += " ";
			}
			buffer += "}";
			MTPI("%s", (const char *)buffer);
			break;
		case kFormDateTime:
			MTPI("	DateTime\n");
			break;
		default:
			MTPI("	form %d\n", mFormFlag);
			break;
	}
}

void MtpProperty::print(MtpPropertyValue& value, MtpString& buffer) {
	switch (mType) {
		case MTP_TYPE_INT8:
			buffer.appendFormat("%d", value.u.i8);
			break;
		case MTP_TYPE_UINT8:
			buffer.appendFormat("%d", value.u.u8);
			break;
		case MTP_TYPE_INT16:
			buffer.appendFormat("%d", value.u.i16);
			break;
		case MTP_TYPE_UINT16:
			buffer.appendFormat("%d", value.u.u16);
			break;
		case MTP_TYPE_INT32:
			buffer.appendFormat("%d", value.u.i32);
			break;
		case MTP_TYPE_UINT32:
			buffer.appendFormat("%d", value.u.u32);
			break;
		case MTP_TYPE_INT64:
			buffer.appendFormat("%lld", value.u.i64);
			break;
		case MTP_TYPE_UINT64:
			buffer.appendFormat("%lld", value.u.u64);
			break;
		case MTP_TYPE_INT128:
			buffer.appendFormat("%08X%08X%08X%08X", value.u.i128[0], value.u.i128[1],
					value.u.i128[2], value.u.i128[3]);
			break;
		case MTP_TYPE_UINT128:
			buffer.appendFormat("%08X%08X%08X%08X", value.u.u128[0], value.u.u128[1],
					value.u.u128[2], value.u.u128[3]);
			break;
		case MTP_TYPE_STR:
			buffer.appendFormat("%s", value.str);
			break;
		default:
			MTPE("unsupported type for MtpProperty::print\n");
			break;
	}
}

void MtpProperty::readValue(MtpDataPacket& packet, MtpPropertyValue& value) {
	MtpStringBuffer stringBuffer;

	switch (mType) {
		case MTP_TYPE_INT8:
		case MTP_TYPE_AINT8:
			value.u.i8 = packet.getInt8();
			break;
		case MTP_TYPE_UINT8:
		case MTP_TYPE_AUINT8:
			value.u.u8 = packet.getUInt8();
			break;
		case MTP_TYPE_INT16:
		case MTP_TYPE_AINT16:
			value.u.i16 = packet.getInt16();
			break;
		case MTP_TYPE_UINT16:
		case MTP_TYPE_AUINT16:
			value.u.u16 = packet.getUInt16();
			break;
		case MTP_TYPE_INT32:
		case MTP_TYPE_AINT32:
			value.u.i32 = packet.getInt32();
			break;
		case MTP_TYPE_UINT32:
		case MTP_TYPE_AUINT32:
			value.u.u32 = packet.getUInt32();
			break;
		case MTP_TYPE_INT64:
		case MTP_TYPE_AINT64:
			value.u.i64 = packet.getInt64();
			break;
		case MTP_TYPE_UINT64:
		case MTP_TYPE_AUINT64:
			value.u.u64 = packet.getUInt64();
			break;
		case MTP_TYPE_INT128:
		case MTP_TYPE_AINT128:
			packet.getInt128(value.u.i128);
			break;
		case MTP_TYPE_UINT128:
		case MTP_TYPE_AUINT128:
			packet.getUInt128(value.u.u128);
			break;
		case MTP_TYPE_STR:
			packet.getString(stringBuffer);
			value.str = strdup(stringBuffer);
			break;
		default:
			MTPE("unknown type %04X in MtpProperty::readValue", mType);
	}
}

void MtpProperty::writeValue(MtpDataPacket& packet, MtpPropertyValue& value) {
	MtpStringBuffer stringBuffer;

	switch (mType) {
		case MTP_TYPE_INT8:
		case MTP_TYPE_AINT8:
			packet.putInt8(value.u.i8);
			break;
		case MTP_TYPE_UINT8:
		case MTP_TYPE_AUINT8:
			packet.putUInt8(value.u.u8);
			break;
		case MTP_TYPE_INT16:
		case MTP_TYPE_AINT16:
			packet.putInt16(value.u.i16);
			break;
		case MTP_TYPE_UINT16:
		case MTP_TYPE_AUINT16:
			packet.putUInt16(value.u.u16);
			break;
		case MTP_TYPE_INT32:
		case MTP_TYPE_AINT32:
			packet.putInt32(value.u.i32);
			break;
		case MTP_TYPE_UINT32:
		case MTP_TYPE_AUINT32:
			packet.putUInt32(value.u.u32);
			break;
		case MTP_TYPE_INT64:
		case MTP_TYPE_AINT64:
			packet.putInt64(value.u.i64);
			break;
		case MTP_TYPE_UINT64:
		case MTP_TYPE_AUINT64:
			packet.putUInt64(value.u.u64);
			break;
		case MTP_TYPE_INT128:
		case MTP_TYPE_AINT128:
			packet.putInt128(value.u.i128);
			break;
		case MTP_TYPE_UINT128:
		case MTP_TYPE_AUINT128:
			packet.putUInt128(value.u.u128);
			break;
		case MTP_TYPE_STR:
			if (value.str)
				packet.putString(value.str);
			else
				packet.putEmptyString();
			break;
		default:
			MTPE("unknown type %04X in MtpProperty::writeValue", mType);
	}
}

MtpPropertyValue* MtpProperty::readArrayValues(MtpDataPacket& packet, int& length) {
	length = packet.getUInt32();
	if (length == 0)
		return NULL;
	MtpPropertyValue* result = new MtpPropertyValue[length];
	for (int i = 0; i < length; i++)
		readValue(packet, result[i]);
	return result;
}

void MtpProperty::writeArrayValues(MtpDataPacket& packet, MtpPropertyValue* values, int length) {
	packet.putUInt32(length);
	for (int i = 0; i < length; i++)
		writeValue(packet, values[i]);
}