Home | History | Annotate | Download | only in jni 
      1 /*
      2  * Copyright 2011, The Android Open Source Project
      3  *
      4  * Redistribution and use in source and binary forms, with or without
      5  * modification, are permitted provided that the following conditions
      6  * are met:
      7  *  * Redistributions of source code must retain the above copyright
      8  *    notice, this list of conditions and the following disclaimer.
      9  *  * Redistributions in binary form must reproduce the above copyright
     10  *    notice, this list of conditions and the following disclaimer in the
     11  *    documentation and/or other materials provided with the distribution.
     12  *
     13  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
     14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
     17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
     18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
     20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
     21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     24  */
     25 
     26 #define LOG_TAG "ViewStateSerializer"
     27 #define LOG_NDEBUG 1
     28 
     29 #include "config.h"
     30 
     31 #include "BaseLayerAndroid.h"
     32 #include "CreateJavaOutputStreamAdaptor.h"
     33 #include "FixedPositioning.h"
     34 #include "ImagesManager.h"
     35 #include "IFrameContentLayerAndroid.h"
     36 #include "IFrameLayerAndroid.h"
     37 #include "Layer.h"
     38 #include "LayerAndroid.h"
     39 #include "LayerContent.h"
     40 #include "PictureLayerContent.h"
     41 #include "ScrollableLayerAndroid.h"
     42 #include "SkFlattenable.h"
     43 #include "SkPicture.h"
     44 #include "TilesManager.h"
     45 
     46 #include <JNIUtility.h>
     47 #include <JNIHelp.h>
     48 #include <jni.h>
     49 
     50 namespace android {
     51 
     52 enum LayerTypes {
     53     LTNone = 0,
     54     LTLayerAndroid = 1,
     55     LTScrollableLayerAndroid = 2,
     56     LTFixedLayerAndroid = 3
     57 };
     58 
     59 static bool nativeSerializeViewState(JNIEnv* env, jobject, jint jbaseLayer,
     60                                      jobject jstream, jbyteArray jstorage)
     61 {
     62     BaseLayerAndroid* baseLayer = (BaseLayerAndroid*) jbaseLayer;
     63     if (!baseLayer)
     64         return false;
     65 
     66     SkWStream *stream = CreateJavaOutputStreamAdaptor(env, jstream, jstorage);
     67 #if USE(ACCELERATED_COMPOSITING)
     68     stream->write32(baseLayer->getBackgroundColor().rgb());
     69 #else
     70     stream->write32(0);
     71 #endif
     72     if (!stream)
     73         return false;
     74     if (baseLayer->content())
     75         baseLayer->content()->serialize(stream);
     76     else
     77         return false;
     78     int childCount = baseLayer->countChildren();
     79     ALOGV("BaseLayer has %d child(ren)", childCount);
     80     stream->write32(childCount);
     81     for (int i = 0; i < childCount; i++) {
     82         LayerAndroid* layer = static_cast<LayerAndroid*>(baseLayer->getChild(i));
     83         serializeLayer(layer, stream);
     84     }
     85     delete stream;
     86     return true;
     87 }
     88 
     89 static BaseLayerAndroid* nativeDeserializeViewState(JNIEnv* env, jobject, jint version,
     90                                                     jobject jstream, jbyteArray jstorage)
     91 {
     92     SkStream* stream = CreateJavaInputStreamAdaptor(env, jstream, jstorage);
     93     if (!stream)
     94         return 0;
     95     Color color = stream->readU32();
     96     SkPicture* picture = new SkPicture(stream);
     97     PictureLayerContent* content = new PictureLayerContent(picture);
     98 
     99     BaseLayerAndroid* layer = new BaseLayerAndroid(content);
    100     layer->setBackgroundColor(color);
    101 
    102     SkRegion dirtyRegion;
    103     dirtyRegion.setRect(0, 0, content->width(), content->height());
    104     layer->markAsDirty(dirtyRegion);
    105 
    106     SkSafeUnref(content);
    107     SkSafeUnref(picture);
    108     int childCount = stream->readS32();
    109     for (int i = 0; i < childCount; i++) {
    110         LayerAndroid* childLayer = deserializeLayer(version, stream);
    111         if (childLayer)
    112             layer->addChild(childLayer);
    113     }
    114     delete stream;
    115     return layer;
    116 }
    117 
    118 // Serialization helpers
    119 
    120 void writeMatrix(SkWStream *stream, const SkMatrix& matrix)
    121 {
    122     for (int i = 0; i < 9; i++)
    123         stream->writeScalar(matrix[i]);
    124 }
    125 
    126 SkMatrix readMatrix(SkStream *stream)
    127 {
    128     SkMatrix matrix;
    129     for (int i = 0; i < 9; i++)
    130         matrix.set(i, stream->readScalar());
    131     return matrix;
    132 }
    133 
    134 void writeSkLength(SkWStream *stream, SkLength length)
    135 {
    136     stream->write32(length.type);
    137     stream->writeScalar(length.value);
    138 }
    139 
    140 SkLength readSkLength(SkStream *stream)
    141 {
    142     SkLength len;
    143     len.type = (SkLength::SkLengthType) stream->readU32();
    144     len.value = stream->readScalar();
    145     return len;
    146 }
    147 
    148 void writeSkRect(SkWStream *stream, SkRect rect)
    149 {
    150     stream->writeScalar(rect.fLeft);
    151     stream->writeScalar(rect.fTop);
    152     stream->writeScalar(rect.fRight);
    153     stream->writeScalar(rect.fBottom);
    154 }
    155 
    156 SkRect readSkRect(SkStream *stream)
    157 {
    158     SkRect rect;
    159     rect.fLeft = stream->readScalar();
    160     rect.fTop = stream->readScalar();
    161     rect.fRight = stream->readScalar();
    162     rect.fBottom = stream->readScalar();
    163     return rect;
    164 }
    165 
    166 void writeTransformationMatrix(SkWStream *stream, TransformationMatrix& matrix)
    167 {
    168     double value;
    169     int dsize = sizeof(double);
    170     value = matrix.m11();
    171     stream->write(&value, dsize);
    172     value = matrix.m12();
    173     stream->write(&value, dsize);
    174     value = matrix.m13();
    175     stream->write(&value, dsize);
    176     value = matrix.m14();
    177     stream->write(&value, dsize);
    178     value = matrix.m21();
    179     stream->write(&value, dsize);
    180     value = matrix.m22();
    181     stream->write(&value, dsize);
    182     value = matrix.m23();
    183     stream->write(&value, dsize);
    184     value = matrix.m24();
    185     stream->write(&value, dsize);
    186     value = matrix.m31();
    187     stream->write(&value, dsize);
    188     value = matrix.m32();
    189     stream->write(&value, dsize);
    190     value = matrix.m33();
    191     stream->write(&value, dsize);
    192     value = matrix.m34();
    193     stream->write(&value, dsize);
    194     value = matrix.m41();
    195     stream->write(&value, dsize);
    196     value = matrix.m42();
    197     stream->write(&value, dsize);
    198     value = matrix.m43();
    199     stream->write(&value, dsize);
    200     value = matrix.m44();
    201     stream->write(&value, dsize);
    202 }
    203 
    204 void readTransformationMatrix(SkStream *stream, TransformationMatrix& matrix)
    205 {
    206     double value;
    207     int dsize = sizeof(double);
    208     stream->read(&value, dsize);
    209     matrix.setM11(value);
    210     stream->read(&value, dsize);
    211     matrix.setM12(value);
    212     stream->read(&value, dsize);
    213     matrix.setM13(value);
    214     stream->read(&value, dsize);
    215     matrix.setM14(value);
    216     stream->read(&value, dsize);
    217     matrix.setM21(value);
    218     stream->read(&value, dsize);
    219     matrix.setM22(value);
    220     stream->read(&value, dsize);
    221     matrix.setM23(value);
    222     stream->read(&value, dsize);
    223     matrix.setM24(value);
    224     stream->read(&value, dsize);
    225     matrix.setM31(value);
    226     stream->read(&value, dsize);
    227     matrix.setM32(value);
    228     stream->read(&value, dsize);
    229     matrix.setM33(value);
    230     stream->read(&value, dsize);
    231     matrix.setM34(value);
    232     stream->read(&value, dsize);
    233     matrix.setM41(value);
    234     stream->read(&value, dsize);
    235     matrix.setM42(value);
    236     stream->read(&value, dsize);
    237     matrix.setM43(value);
    238     stream->read(&value, dsize);
    239     matrix.setM44(value);
    240 }
    241 
    242 void serializeLayer(LayerAndroid* layer, SkWStream* stream)
    243 {
    244     if (!layer) {
    245         ALOGV("NULL layer!");
    246         stream->write8(LTNone);
    247         return;
    248     }
    249     if (layer->isMedia() || layer->isVideo()) {
    250         ALOGV("Layer isn't supported for serialization: isMedia: %s, isVideo: %s",
    251              layer->isMedia() ? "true" : "false",
    252              layer->isVideo() ? "true" : "false");
    253         stream->write8(LTNone);
    254         return;
    255     }
    256     LayerTypes type = LTLayerAndroid;
    257     if (layer->contentIsScrollable())
    258         type = LTScrollableLayerAndroid;
    259     stream->write8(type);
    260 
    261     // Start with Layer fields
    262     stream->writeBool(layer->shouldInheritFromRootTransform());
    263     stream->writeScalar(layer->getOpacity());
    264     stream->writeScalar(layer->getSize().width());
    265     stream->writeScalar(layer->getSize().height());
    266     stream->writeScalar(layer->getPosition().x());
    267     stream->writeScalar(layer->getPosition().y());
    268     stream->writeScalar(layer->getAnchorPoint().x());
    269     stream->writeScalar(layer->getAnchorPoint().y());
    270     writeMatrix(stream, layer->getMatrix());
    271     writeMatrix(stream, layer->getChildrenMatrix());
    272 
    273     // Next up, LayerAndroid fields
    274     stream->writeBool(layer->m_haveClip);
    275     stream->writeBool(layer->isPositionFixed());
    276     stream->writeBool(layer->m_backgroundColorSet);
    277     stream->writeBool(layer->isIFrame());
    278 
    279     // With the current LayerAndroid hierarchy, LayerAndroid doesn't have
    280     // those fields anymore. Let's keep the current serialization format for
    281     // now and output blank fields... not great, but probably better than
    282     // dealing with multiple versions.
    283     if (layer->fixedPosition()) {
    284         FixedPositioning* fixedPosition = layer->fixedPosition();
    285         writeSkLength(stream, fixedPosition->m_fixedLeft);
    286         writeSkLength(stream, fixedPosition->m_fixedTop);
    287         writeSkLength(stream, fixedPosition->m_fixedRight);
    288         writeSkLength(stream, fixedPosition->m_fixedBottom);
    289         writeSkLength(stream, fixedPosition->m_fixedMarginLeft);
    290         writeSkLength(stream, fixedPosition->m_fixedMarginTop);
    291         writeSkLength(stream, fixedPosition->m_fixedMarginRight);
    292         writeSkLength(stream, fixedPosition->m_fixedMarginBottom);
    293         writeSkRect(stream, fixedPosition->m_fixedRect);
    294         stream->write32(fixedPosition->m_renderLayerPos.x());
    295         stream->write32(fixedPosition->m_renderLayerPos.y());
    296     } else {
    297         SkLength length;
    298         SkRect rect;
    299         writeSkLength(stream, length); // fixedLeft
    300         writeSkLength(stream, length); // fixedTop
    301         writeSkLength(stream, length); // fixedRight
    302         writeSkLength(stream, length); // fixedBottom
    303         writeSkLength(stream, length); // fixedMarginLeft
    304         writeSkLength(stream, length); // fixedMarginTop
    305         writeSkLength(stream, length); // fixedMarginRight
    306         writeSkLength(stream, length); // fixedMarginBottom
    307         writeSkRect(stream, rect);     // fixedRect
    308         stream->write32(0);            // renderLayerPos.x()
    309         stream->write32(0);            // renderLayerPos.y()
    310     }
    311 
    312     stream->writeBool(layer->m_backfaceVisibility);
    313     stream->writeBool(layer->m_visible);
    314     stream->write32(layer->m_backgroundColor);
    315     stream->writeBool(layer->m_preserves3D);
    316     stream->writeScalar(layer->m_anchorPointZ);
    317     stream->writeScalar(layer->m_drawOpacity);
    318     bool hasContentsImage = layer->m_imageCRC != 0;
    319     stream->writeBool(hasContentsImage);
    320     if (hasContentsImage) {
    321         SkFlattenableWriteBuffer buffer(1024);
    322         buffer.setFlags(SkFlattenableWriteBuffer::kCrossProcess_Flag);
    323         ImageTexture* imagetexture =
    324                 ImagesManager::instance()->retainImage(layer->m_imageCRC);
    325         if (imagetexture && imagetexture->bitmap())
    326             imagetexture->bitmap()->flatten(buffer);
    327         ImagesManager::instance()->releaseImage(layer->m_imageCRC);
    328         stream->write32(buffer.size());
    329         buffer.writeToStream(stream);
    330     }
    331     bool hasRecordingPicture = layer->m_content != 0 && !layer->m_content->isEmpty();
    332     stream->writeBool(hasRecordingPicture);
    333     if (hasRecordingPicture)
    334         layer->m_content->serialize(stream);
    335     // TODO: support m_animations (maybe?)
    336     stream->write32(0); // placeholder for m_animations.size();
    337     writeTransformationMatrix(stream, layer->m_transform);
    338     writeTransformationMatrix(stream, layer->m_childrenTransform);
    339     if (type == LTScrollableLayerAndroid) {
    340         ScrollableLayerAndroid* scrollableLayer =
    341                 static_cast<ScrollableLayerAndroid*>(layer);
    342         stream->writeScalar(scrollableLayer->m_scrollLimits.fLeft);
    343         stream->writeScalar(scrollableLayer->m_scrollLimits.fTop);
    344         stream->writeScalar(scrollableLayer->m_scrollLimits.width());
    345         stream->writeScalar(scrollableLayer->m_scrollLimits.height());
    346     }
    347     int childCount = layer->countChildren();
    348     stream->write32(childCount);
    349     for (int i = 0; i < childCount; i++)
    350         serializeLayer(layer->getChild(i), stream);
    351 }
    352 
    353 LayerAndroid* deserializeLayer(int version, SkStream* stream)
    354 {
    355     int type = stream->readU8();
    356     if (type == LTNone)
    357         return 0;
    358     // Cast is to disambiguate between ctors.
    359     LayerAndroid *layer;
    360     if (type == LTLayerAndroid)
    361         layer = new LayerAndroid((RenderLayer*) 0);
    362     else if (type == LTScrollableLayerAndroid)
    363         layer = new ScrollableLayerAndroid((RenderLayer*) 0);
    364     else {
    365         ALOGV("Unexpected layer type: %d, aborting!", type);
    366         return 0;
    367     }
    368 
    369     // Layer fields
    370     layer->setShouldInheritFromRootTransform(stream->readBool());
    371     layer->setOpacity(stream->readScalar());
    372     layer->setSize(stream->readScalar(), stream->readScalar());
    373     layer->setPosition(stream->readScalar(), stream->readScalar());
    374     layer->setAnchorPoint(stream->readScalar(), stream->readScalar());
    375     layer->setMatrix(readMatrix(stream));
    376     layer->setChildrenMatrix(readMatrix(stream));
    377 
    378     // LayerAndroid fields
    379     layer->m_haveClip = stream->readBool();
    380 
    381     // Keep the legacy serialization/deserialization format...
    382     bool isFixed = stream->readBool();
    383 
    384     layer->m_backgroundColorSet = stream->readBool();
    385 
    386     bool isIframe = stream->readBool();
    387     // If we are a scrollable layer android, we are an iframe content
    388     if (isIframe && type == LTScrollableLayerAndroid) {
    389          IFrameContentLayerAndroid* iframeContent = new IFrameContentLayerAndroid(*layer);
    390          layer->unref();
    391          layer = iframeContent;
    392     } else if (isIframe) { // otherwise we are just the iframe (we use it to compute offset)
    393          IFrameLayerAndroid* iframe = new IFrameLayerAndroid(*layer);
    394          layer->unref();
    395          layer = iframe;
    396     }
    397 
    398     if (isFixed) {
    399         FixedPositioning* fixedPosition = new FixedPositioning(layer);
    400 
    401         fixedPosition->m_fixedLeft = readSkLength(stream);
    402         fixedPosition->m_fixedTop = readSkLength(stream);
    403         fixedPosition->m_fixedRight = readSkLength(stream);
    404         fixedPosition->m_fixedBottom = readSkLength(stream);
    405         fixedPosition->m_fixedMarginLeft = readSkLength(stream);
    406         fixedPosition->m_fixedMarginTop = readSkLength(stream);
    407         fixedPosition->m_fixedMarginRight = readSkLength(stream);
    408         fixedPosition->m_fixedMarginBottom = readSkLength(stream);
    409         fixedPosition->m_fixedRect = readSkRect(stream);
    410         fixedPosition->m_renderLayerPos.setX(stream->readS32());
    411         fixedPosition->m_renderLayerPos.setY(stream->readS32());
    412 
    413         layer->setFixedPosition(fixedPosition);
    414     } else {
    415         // Not a fixed element, bypass the values in the stream
    416         readSkLength(stream); // fixedLeft
    417         readSkLength(stream); // fixedTop
    418         readSkLength(stream); // fixedRight
    419         readSkLength(stream); // fixedBottom
    420         readSkLength(stream); // fixedMarginLeft
    421         readSkLength(stream); // fixedMarginTop
    422         readSkLength(stream); // fixedMarginRight
    423         readSkLength(stream); // fixedMarginBottom
    424         readSkRect(stream);   // fixedRect
    425         stream->readS32();    // renderLayerPos.x()
    426         stream->readS32();    // renderLayerPos.y()
    427     }
    428 
    429     layer->m_backfaceVisibility = stream->readBool();
    430     layer->m_visible = stream->readBool();
    431     layer->m_backgroundColor = stream->readU32();
    432     layer->m_preserves3D = stream->readBool();
    433     layer->m_anchorPointZ = stream->readScalar();
    434     layer->m_drawOpacity = stream->readScalar();
    435     bool hasContentsImage = stream->readBool();
    436     if (hasContentsImage) {
    437         int size = stream->readU32();
    438         SkAutoMalloc storage(size);
    439         stream->read(storage.get(), size);
    440         SkFlattenableReadBuffer buffer(storage.get(), size);
    441         SkBitmap contentsImage;
    442         contentsImage.unflatten(buffer);
    443         SkBitmapRef* imageRef = new SkBitmapRef(contentsImage);
    444         layer->setContentsImage(imageRef);
    445         delete imageRef;
    446     }
    447     bool hasRecordingPicture = stream->readBool();
    448     if (hasRecordingPicture) {
    449         SkPicture* picture = new SkPicture(stream);
    450         PictureLayerContent* content = new PictureLayerContent(picture);
    451         layer->setContent(content);
    452         SkSafeUnref(content);
    453         SkSafeUnref(picture);
    454     }
    455     int animationCount = stream->readU32(); // TODO: Support (maybe?)
    456     readTransformationMatrix(stream, layer->m_transform);
    457     readTransformationMatrix(stream, layer->m_childrenTransform);
    458     if (type == LTScrollableLayerAndroid) {
    459         ScrollableLayerAndroid* scrollableLayer =
    460                 static_cast<ScrollableLayerAndroid*>(layer);
    461         scrollableLayer->m_scrollLimits.set(
    462                 stream->readScalar(),
    463                 stream->readScalar(),
    464                 stream->readScalar(),
    465                 stream->readScalar());
    466     }
    467     int childCount = stream->readU32();
    468     for (int i = 0; i < childCount; i++) {
    469         LayerAndroid *childLayer = deserializeLayer(version, stream);
    470         if (childLayer)
    471             layer->addChild(childLayer);
    472     }
    473     ALOGV("Created layer with id %d", layer->uniqueId());
    474     return layer;
    475 }
    476 
    477 /*
    478  * JNI registration
    479  */
    480 static JNINativeMethod gSerializerMethods[] = {
    481     { "nativeSerializeViewState", "(ILjava/io/OutputStream;[B)Z",
    482         (void*) nativeSerializeViewState },
    483     { "nativeDeserializeViewState", "(ILjava/io/InputStream;[B)I",
    484         (void*) nativeDeserializeViewState },
    485 };
    486 
    487 int registerViewStateSerializer(JNIEnv* env)
    488 {
    489     return jniRegisterNativeMethods(env, "android/webkit/ViewStateSerializer",
    490                                     gSerializerMethods, NELEM(gSerializerMethods));
    491 }
    492 
    493 }
    494