Picture.cpp revision b59508fce51b23f0201f4dcba7e4f18bab4f9d1a 
1/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "jni.h"
18#include "GraphicsJNI.h"
19#include <android_runtime/AndroidRuntime.h>
20#include "AndroidPicture.h"
21
22#include "SkCanvas.h"
23#include "SkStream.h"
24#include "SkTemplates.h"
25#include "CreateJavaOutputStreamAdaptor.h"
26
27namespace android {
28
29class SkPictureGlue {
30public:
31    static jlong newPicture(JNIEnv* env, jobject, jlong srcHandle) {
32        const AndroidPicture* src = reinterpret_cast<AndroidPicture*>(srcHandle);
33        return reinterpret_cast<jlong>(new AndroidPicture(src));
34    }
35
36    static jlong deserialize(JNIEnv* env, jobject, jobject jstream,
37                             jbyteArray jstorage) {
38        AndroidPicture* picture = NULL;
39        SkStream* strm = CreateJavaInputStreamAdaptor(env, jstream, jstorage);
40        if (strm) {
41            picture = AndroidPicture::CreateFromStream(strm);
42            delete strm;
43        }
44        return reinterpret_cast<jlong>(picture);
45    }
46
47    static void killPicture(JNIEnv* env, jobject, jlong pictureHandle) {
48        AndroidPicture* picture = reinterpret_cast<AndroidPicture*>(pictureHandle);
49        SkASSERT(picture);
50        delete picture;
51    }
52
53    static void draw(JNIEnv* env, jobject, jlong canvasHandle,
54                            jlong pictureHandle) {
55        SkCanvas* canvas = GraphicsJNI::getNativeCanvas(canvasHandle);
56        AndroidPicture* picture = reinterpret_cast<AndroidPicture*>(pictureHandle);
57        SkASSERT(canvas);
58        SkASSERT(picture);
59        picture->draw(canvas);
60    }
61
62    static jboolean serialize(JNIEnv* env, jobject, jlong pictureHandle,
63                              jobject jstream, jbyteArray jstorage) {
64        AndroidPicture* picture = reinterpret_cast<AndroidPicture*>(pictureHandle);
65        SkWStream* strm = CreateJavaOutputStreamAdaptor(env, jstream, jstorage);
66
67        if (NULL != strm) {
68            picture->serialize(strm);
69            delete strm;
70            return JNI_TRUE;
71        }
72        return JNI_FALSE;
73    }
74
75    static jint getWidth(JNIEnv* env, jobject jpic) {
76        NPE_CHECK_RETURN_ZERO(env, jpic);
77        AndroidPicture* pict = GraphicsJNI::getNativePicture(env, jpic);
78        int width = pict->width();
79        return static_cast<jint>(width);
80    }
81
82    static jint getHeight(JNIEnv* env, jobject jpic) {
83        NPE_CHECK_RETURN_ZERO(env, jpic);
84        AndroidPicture* pict = GraphicsJNI::getNativePicture(env, jpic);
85        int height = pict->height();
86        return static_cast<jint>(height);
87    }
88
89    static jlong beginRecording(JNIEnv* env, jobject, jlong pictHandle,
90                                jint w, jint h) {
91        AndroidPicture* pict = reinterpret_cast<AndroidPicture*>(pictHandle);
92        // beginRecording does not ref its return value, it just returns it.
93        SkCanvas* canvas = pict->beginRecording(w, h);
94        // the java side will wrap this guy in a Canvas.java, which will call
95        // unref in its finalizer, so we have to ref it here, so that both that
96        // Canvas.java and our picture can both be owners
97        canvas->ref();
98        return reinterpret_cast<jlong>(canvas);
99    }
100
101    static void endRecording(JNIEnv* env, jobject, jlong pictHandle) {
102        AndroidPicture* pict = reinterpret_cast<AndroidPicture*>(pictHandle);
103        pict->endRecording();
104    }
105};
106
107static JNINativeMethod gPictureMethods[] = {
108    {"getWidth", "()I", (void*) SkPictureGlue::getWidth},
109    {"getHeight", "()I", (void*) SkPictureGlue::getHeight},
110    {"nativeConstructor", "(J)J", (void*) SkPictureGlue::newPicture},
111    {"nativeCreateFromStream", "(Ljava/io/InputStream;[B)J", (void*)SkPictureGlue::deserialize},
112    {"nativeBeginRecording", "(JII)J", (void*) SkPictureGlue::beginRecording},
113    {"nativeEndRecording", "(J)V", (void*) SkPictureGlue::endRecording},
114    {"nativeDraw", "(JJ)V", (void*) SkPictureGlue::draw},
115    {"nativeWriteToStream", "(JLjava/io/OutputStream;[B)Z", (void*)SkPictureGlue::serialize},
116    {"nativeDestructor","(J)V", (void*) SkPictureGlue::killPicture}
117};
118
119#include <android_runtime/AndroidRuntime.h>
120
121#define REG(env, name, array) \
122    result = android::AndroidRuntime::registerNativeMethods(env, name, array, \
123    SK_ARRAY_COUNT(array));  \
124    if (result < 0) return result
125
126int register_android_graphics_Picture(JNIEnv* env) {
127    int result;
128
129    REG(env, "android/graphics/Picture", gPictureMethods);
130
131    return result;
132}
133
134}
135
136
137