def readParameters(self, coordinatesTableSize, parametersDescriptors):
parametersStream = io.BytesIO(
bytearray(self._stream.read(coordinatesTableSize)))
result = []
for parameterDescriptor in parametersDescriptors:
descriptorOffset = parameterDescriptor.getChildren()[0].getValue()
descriptorLength = parameterDescriptor.getChildren()[1].getValue()
logging.info(
f"Reading descriptor for parameter {parameterDescriptor.getId()}"
)
logging.info(
f"Descriptor offset: {descriptorOffset}, Descriptor length: {descriptorLength}"
)
parametersStream.seek(descriptorOffset)
descriptorStream = io.BytesIO(
bytearray(parametersStream.read(descriptorLength)))
logging.info(
f"Parsing descriptor for parameter {parameterDescriptor.getId()}..."
)
result.append(
Parameter(parameterDescriptor.getId(),
Parameter.readList(descriptorStream)))
return result
def read(self):
logging.info("Reading header...")
from watchFaceParser.models.header import Header
header = Header.readFrom(self._stream)
logging.info("Header was read:")
logging.info(
f"Signature: {header.signature}, Unknown: {header.unknown}, ParametersSize: {header.parametersSize}, isValid: {header.isValid()}"
)
if not header.isValid():
return
logging.info("Reading parameter offsets...")
tmpArray = bytearray(self._stream.read(header.parametersSize))
parametersStream = io.BytesIO(tmpArray)
logging.info("Parameter offsets were read from file")
logging.info("Reading parameters descriptor...")
mainParam = Parameter.readFrom(parametersStream)
logging.info("getParameters descriptor was read:")
parametersTableLength = mainParam.getChildren()[0].getValue()
imagesCount = mainParam.getChildren()[1].getValue()
logging.info(
f"ParametersTableLength: {parametersTableLength}, ImagesCount: {imagesCount}"
)
logging.info("Reading parameters locations...")
parametersLocations = Parameter.readList(parametersStream)
logging.info("Watch face parameters locations were read:")
self._parameters = self.readParameters(parametersTableLength,
parametersLocations)
from resources.reader import Reader
self._resources = Reader(self._stream).read(imagesCount)
def build(T, serializable, path = ""):
result = []
properties = ElementsHelper.sortedProperties(T)
for _id in properties:
currentPath = str(_id) if path == None or path == '' else ''.join([path, '.', str(_id)])
propertyInfo = properties[_id]
if isinstance(propertyInfo['Type'],list):
propertyType = propertyInfo['Type'][0]
else:
propertyType = propertyInfo['Type']
propertyValue = ParametersConverter.getValue(propertyInfo, serializable)
if propertyValue is None:
continue
if propertyType == 'long' or propertyType == 'long?' or propertyType == TextAlignment or propertyType == Color or propertyType == 'bool':
value = propertyValue
if propertyType == 'bool' or type(propertyValue) == bool:
value = 1 if propertyValue else 0
elif propertyType == TextAlignment:
value = TextAlignment.fromJSON(propertyValue)
elif propertyType == Color:
value = Color.fromJSON(propertyValue)
elif propertyType == 'long' or propertyType == 'long?':
value = int(value)
logging.debug(f"{currentPath} '{propertyInfo['Name']}': {value}")
result.append(Parameter(_id, value))
elif propertyType == ParameterFlags:
flags = ParameterFlags.fromJSON(propertyValue)
logging.debug(f"{currentPath} '{propertyInfo['Name']}': {flags}")
result.append(Parameter(_id, None, flags = flags))
else:
if isinstance(propertyValue,list):
for i in propertyValue:
innerParameters = ParametersConverter.build(propertyType, i, currentPath)
if len(innerParameters) > 0:
logging.debug(f"{currentPath} '{propertyInfo['Name']}'")
result.append(Parameter(_id, innerParameters))
else:
logging.debug(f"{currentPath} '{propertyInfo['Name']}': Skipped because of empty1")
continue
innerParameters = ParametersConverter.build(propertyType, propertyValue, currentPath)
if len(innerParameters) > 0:
logging.debug(f"{currentPath} '{propertyInfo['Name']}'")
result.append(Parameter(_id, innerParameters))
else:
logging.debug(f"{currentPath} '{propertyInfo['Name']}': Skipped because of empty2")
return result
def write(self, descriptor):
logging.debug("Encoding parameters...")
encodedParameters = {}
for parameter in descriptor:
logging.debug(f"Parameter: {parameter.getId()}")
memoryStream = io.BytesIO()
for child in parameter.getChildren():
child.write(memoryStream)
encodedParameters[parameter.getId()] = memoryStream
logging.debug("Encoding offsets and lengths...")
parametersPositions = []
offset = 0
maxEncodedParametersLength = 0
from watchFaceParser.models.parameter import Parameter
for encodedParameterId in encodedParameters:
encodedParameterLength = len(encodedParameters[encodedParameterId].getbuffer())
maxEncodedParametersLength = max(maxEncodedParametersLength, encodedParameterLength)
parametersPositions.append(Parameter(encodedParameterId, [ Parameter(1, offset), Parameter(2, encodedParameterLength) ]))
offset += encodedParameterLength
parametersPositions.insert(0, Parameter(1, [ Parameter(1, offset), Parameter(2, len(self._images)) ]))
encodedParametersPositions = io.BytesIO()
for parametersPosition in parametersPositions:
parametersPosition.write(encodedParametersPositions)
logging.debug("Writing header...")
from watchFaceParser.models.header import Header
header = Header(unknown = maxEncodedParametersLength, parametersSize = len(encodedParametersPositions.getbuffer()))
header.writeTo(self._stream)
logging.debug("Writing parameters offsets and lengths...")
encodedParametersPositions.seek(0, 0)
self._stream.write(encodedParametersPositions.read())
logging.debug("Writing parameters...")
for encodedParameter in encodedParameters:
stream = encodedParameters[encodedParameter]
stream.seek(0, 0)
self._stream.write(stream.read())
logging.debug("Writing images...")
from resources.writer import Writer
Writer(self._stream).write(self._images)