#include "BaseLayerAndroid.h"
#include "CreateJavaOutputStreamAdaptor.h"
+#include "LayerAndroid.h"
#include "PictureSet.h"
+#include "ScrollableLayerAndroid.h"
+#include "SkLayer.h"
#include "SkPicture.h"
#include <JNIUtility.h>
#include <JNIHelp.h>
#include <jni.h>
+#ifdef DEBUG
+
+#undef XLOG
+#define XLOG(...) android_printLog(ANDROID_LOG_DEBUG, "ViewStateSerializer", __VA_ARGS__)
+
+#else
+
+#undef XLOG
+#define XLOG(...)
+
+#endif // DEBUG
+
namespace android {
+enum LayerTypes {
+ LTNone = 0,
+ LTLayerAndroid = 1,
+ LTScrollableLayerAndroid = 2,
+};
+
static bool nativeSerializeViewState(JNIEnv* env, jobject, jint jbaseLayer,
jobject jstream, jbyteArray jstorage)
{
if (!stream)
return false;
picture.serialize(stream);
+ int childCount = baseLayer->countChildren();
+ XLOG("BaseLayer has %d child(ren)", childCount);
+ stream->write32(childCount);
+ for (int i = 0; i < childCount; i++) {
+ LayerAndroid* layer = static_cast<LayerAndroid*>(baseLayer->getChild(i));
+ serializeLayer(layer, stream);
+ }
delete stream;
return true;
}
layer->setBackgroundColor(color);
#endif
SkPicture* picture = new SkPicture(stream);
- delete stream;
layer->setContent(picture);
+ SkSafeUnref(picture);
+ int childCount = stream->readS32();
+ for (int i = 0; i < childCount; i++) {
+ LayerAndroid* childLayer = deserializeLayer(stream);
+ if (childLayer)
+ layer->addChild(childLayer);
+ }
+ delete stream;
+ return layer;
+}
+
+// Serialization helpers
+
+void writeMatrix(SkWStream *stream, const SkMatrix& matrix)
+{
+ for (int i = 0; i < 9; i++)
+ stream->writeScalar(matrix[i]);
+}
+
+SkMatrix readMatrix(SkStream *stream)
+{
+ SkMatrix matrix;
+ for (int i = 0; i < 9; i++)
+ matrix.set(i, stream->readScalar());
+ return matrix;
+}
+
+void writeSkLength(SkWStream *stream, SkLength length)
+{
+ stream->write32(length.type);
+ stream->writeScalar(length.value);
+}
+
+SkLength readSkLength(SkStream *stream)
+{
+ SkLength len;
+ len.type = (SkLength::SkLengthType) stream->readU32();
+ len.value = stream->readScalar();
+ return len;
+}
+
+void writeSkRect(SkWStream *stream, SkRect rect)
+{
+ stream->writeScalar(rect.fLeft);
+ stream->writeScalar(rect.fTop);
+ stream->writeScalar(rect.fRight);
+ stream->writeScalar(rect.fBottom);
+}
+
+SkRect readSkRect(SkStream *stream)
+{
+ SkRect rect;
+ rect.fLeft = stream->readScalar();
+ rect.fTop = stream->readScalar();
+ rect.fRight = stream->readScalar();
+ rect.fBottom = stream->readScalar();
+ return rect;
+}
+
+void writeTransformationMatrix(SkWStream *stream, TransformationMatrix& matrix)
+{
+ double value;
+ int dsize = sizeof(double);
+ value = matrix.m11();
+ stream->write(&value, dsize);
+ value = matrix.m12();
+ stream->write(&value, dsize);
+ value = matrix.m13();
+ stream->write(&value, dsize);
+ value = matrix.m14();
+ stream->write(&value, dsize);
+ value = matrix.m21();
+ stream->write(&value, dsize);
+ value = matrix.m22();
+ stream->write(&value, dsize);
+ value = matrix.m23();
+ stream->write(&value, dsize);
+ value = matrix.m24();
+ stream->write(&value, dsize);
+ value = matrix.m31();
+ stream->write(&value, dsize);
+ value = matrix.m32();
+ stream->write(&value, dsize);
+ value = matrix.m33();
+ stream->write(&value, dsize);
+ value = matrix.m34();
+ stream->write(&value, dsize);
+ value = matrix.m41();
+ stream->write(&value, dsize);
+ value = matrix.m42();
+ stream->write(&value, dsize);
+ value = matrix.m43();
+ stream->write(&value, dsize);
+ value = matrix.m44();
+ stream->write(&value, dsize);
+}
+
+void readTransformationMatrix(SkStream *stream, TransformationMatrix& matrix)
+{
+ double value;
+ int dsize = sizeof(double);
+ stream->read(&value, dsize);
+ matrix.setM11(value);
+ stream->read(&value, dsize);
+ matrix.setM12(value);
+ stream->read(&value, dsize);
+ matrix.setM13(value);
+ stream->read(&value, dsize);
+ matrix.setM14(value);
+ stream->read(&value, dsize);
+ matrix.setM21(value);
+ stream->read(&value, dsize);
+ matrix.setM22(value);
+ stream->read(&value, dsize);
+ matrix.setM23(value);
+ stream->read(&value, dsize);
+ matrix.setM24(value);
+ stream->read(&value, dsize);
+ matrix.setM31(value);
+ stream->read(&value, dsize);
+ matrix.setM32(value);
+ stream->read(&value, dsize);
+ matrix.setM33(value);
+ stream->read(&value, dsize);
+ matrix.setM34(value);
+ stream->read(&value, dsize);
+ matrix.setM41(value);
+ stream->read(&value, dsize);
+ matrix.setM42(value);
+ stream->read(&value, dsize);
+ matrix.setM43(value);
+ stream->read(&value, dsize);
+ matrix.setM44(value);
+}
+
+void serializeLayer(LayerAndroid* layer, SkWStream* stream)
+{
+ if (!layer) {
+ XLOG("NULL layer!");
+ stream->write8(LTNone);
+ return;
+ }
+ if (layer->isMedia() || layer->isVideo()) {
+ XLOG("Layer isn't supported for serialization: isMedia: %s, isVideo: %s",
+ layer->isMedia() ? "true" : "false",
+ layer->isVideo() ? "true" : "false");
+ stream->write8(LTNone);
+ return;
+ }
+ LayerTypes type = layer->contentIsScrollable()
+ ? LTScrollableLayerAndroid
+ : LTLayerAndroid;
+ stream->write8(type);
+
+ // Start with SkLayer fields
+ stream->writeBool(layer->isInheritFromRootTransform());
+ stream->writeScalar(layer->getOpacity());
+ stream->writeScalar(layer->getSize().width());
+ stream->writeScalar(layer->getSize().height());
+ stream->writeScalar(layer->getPosition().x());
+ stream->writeScalar(layer->getPosition().y());
+ stream->writeScalar(layer->getAnchorPoint().x());
+ stream->writeScalar(layer->getAnchorPoint().y());
+ writeMatrix(stream, layer->getMatrix());
+ writeMatrix(stream, layer->getChildrenMatrix());
+
+ // Next up, LayerAndroid fields
+ stream->writeBool(layer->m_haveClip);
+ stream->writeBool(layer->m_isFixed);
+ stream->writeBool(layer->m_backgroundColorSet);
+ stream->writeBool(layer->m_isIframe);
+ writeSkLength(stream, layer->m_fixedLeft);
+ writeSkLength(stream, layer->m_fixedTop);
+ writeSkLength(stream, layer->m_fixedRight);
+ writeSkLength(stream, layer->m_fixedBottom);
+ writeSkLength(stream, layer->m_fixedMarginLeft);
+ writeSkLength(stream, layer->m_fixedMarginTop);
+ writeSkLength(stream, layer->m_fixedMarginRight);
+ writeSkLength(stream, layer->m_fixedMarginBottom);
+ writeSkRect(stream, layer->m_fixedRect);
+ stream->write32(layer->m_renderLayerPos.x());
+ stream->write32(layer->m_renderLayerPos.y());
+ stream->writeBool(layer->m_backfaceVisibility);
+ stream->writeBool(layer->m_visible);
+ stream->write32(layer->m_backgroundColor);
+ stream->writeBool(layer->m_preserves3D);
+ stream->writeScalar(layer->m_anchorPointZ);
+ stream->writeScalar(layer->m_drawOpacity);
+ bool hasContentsImage = layer->m_contentsImage != 0;
+ stream->writeBool(hasContentsImage);
+ if (hasContentsImage) {
+ SkFlattenableWriteBuffer buffer(1024);
+ buffer.setFlags(SkFlattenableWriteBuffer::kCrossProcess_Flag);
+ layer->m_contentsImage->flatten(buffer);
+ stream->write32(buffer.size());
+ buffer.writeToStream(stream);
+ }
+ bool hasRecordingPicture = layer->m_recordingPicture != 0;
+ stream->writeBool(hasRecordingPicture);
+ if (hasRecordingPicture)
+ layer->m_recordingPicture->serialize(stream);
+ // TODO: support m_animations (maybe?)
+ stream->write32(0); // placeholder for m_animations.size();
+ writeTransformationMatrix(stream, layer->m_transform);
+ writeTransformationMatrix(stream, layer->m_childrenTransform);
+ if (type == LTScrollableLayerAndroid) {
+ ScrollableLayerAndroid* scrollableLayer =
+ static_cast<ScrollableLayerAndroid*>(layer);
+ stream->writeScalar(scrollableLayer->m_scrollLimits.fLeft);
+ stream->writeScalar(scrollableLayer->m_scrollLimits.fTop);
+ stream->writeScalar(scrollableLayer->m_scrollLimits.width());
+ stream->writeScalar(scrollableLayer->m_scrollLimits.height());
+ }
+ int childCount = layer->countChildren();
+ stream->write32(childCount);
+ for (int i = 0; i < childCount; i++)
+ serializeLayer(layer->getChild(i), stream);
+}
+
+LayerAndroid* deserializeLayer(SkStream* stream)
+{
+ int type = stream->readU8();
+ if (type == LTNone)
+ return 0;
+ // Cast is to disambiguate between ctors.
+ LayerAndroid *layer;
+ if (type == LTLayerAndroid)
+ layer = new LayerAndroid((RenderLayer*) 0);
+ else if (type == LTScrollableLayerAndroid)
+ layer = new ScrollableLayerAndroid((RenderLayer*) 0);
+ else {
+ XLOG("Unexpected layer type: %d, aborting!", type);
+ return 0;
+ }
+
+ // SkLayer fields
+ layer->setInheritFromRootTransform(stream->readBool());
+ layer->setOpacity(stream->readScalar());
+ layer->setSize(stream->readScalar(), stream->readScalar());
+ layer->setPosition(stream->readScalar(), stream->readScalar());
+ layer->setAnchorPoint(stream->readScalar(), stream->readScalar());
+ layer->setMatrix(readMatrix(stream));
+ layer->setChildrenMatrix(readMatrix(stream));
+
+ // LayerAndroid fields
+ layer->m_haveClip = stream->readBool();
+ layer->m_isFixed = stream->readBool();
+ layer->m_backgroundColorSet = stream->readBool();
+ layer->m_isIframe = stream->readBool();
+ layer->m_fixedLeft = readSkLength(stream);
+ layer->m_fixedTop = readSkLength(stream);
+ layer->m_fixedRight = readSkLength(stream);
+ layer->m_fixedBottom = readSkLength(stream);
+ layer->m_fixedMarginLeft = readSkLength(stream);
+ layer->m_fixedMarginTop = readSkLength(stream);
+ layer->m_fixedMarginRight = readSkLength(stream);
+ layer->m_fixedMarginBottom = readSkLength(stream);
+ layer->m_fixedRect = readSkRect(stream);
+ layer->m_renderLayerPos.setX(stream->readS32());
+ layer->m_renderLayerPos.setY(stream->readS32());
+ layer->m_backfaceVisibility = stream->readBool();
+ layer->m_visible = stream->readBool();
+ layer->m_backgroundColor = stream->readU32();
+ layer->m_preserves3D = stream->readBool();
+ layer->m_anchorPointZ = stream->readScalar();
+ layer->m_drawOpacity = stream->readScalar();
+ bool hasContentsImage = stream->readBool();
+ if (hasContentsImage) {
+ int size = stream->readU32();
+ SkAutoMalloc storage(size);
+ stream->read(storage.get(), size);
+ SkFlattenableReadBuffer buffer(storage.get(), size);
+ layer->m_contentsImage = new SkBitmap();
+ layer->m_contentsImage->unflatten(buffer);
+ }
+ bool hasRecordingPicture = stream->readBool();
+ if (hasRecordingPicture) {
+ layer->m_recordingPicture = new SkPicture(stream);
+ }
+ int animationCount = stream->readU32(); // TODO: Support (maybe?)
+ readTransformationMatrix(stream, layer->m_transform);
+ readTransformationMatrix(stream, layer->m_childrenTransform);
+ if (type == LTScrollableLayerAndroid) {
+ ScrollableLayerAndroid* scrollableLayer =
+ static_cast<ScrollableLayerAndroid*>(layer);
+ scrollableLayer->m_scrollLimits.set(
+ stream->readScalar(),
+ stream->readScalar(),
+ stream->readScalar(),
+ stream->readScalar());
+ }
+ int childCount = stream->readU32();
+ for (int i = 0; i < childCount; i++) {
+ LayerAndroid *childLayer = deserializeLayer(stream);
+ if (childLayer)
+ layer->addChild(childLayer);
+ }
+ layer->needsRepaint();
+ XLOG("Created layer with id %d", layer->uniqueId());
return layer;
}
OSDN Git Service
