Internally the API uses the same code path as SkTypeface::CreateFromName which
returns NULL if the requested style is not supported by the existing family.
However, the existing Java API expects that we return the default font in the
requested style so this CL ensures that we do.
bug: 10860066
Change-Id: Ide3a0cc24015e97fa35aef283b42e7d7d11edd9c
1. Move PdfDocument to android.graphics.pdf.
2. Changed the PdfDocument as per API concil request.
3. Updated the documentation.
bug:10461180
bug:10552565
bug:10681585
bug:10552336
Change-Id: I08e15b34cf37bb064248c887e6f59808019cafe8
If pixel memory was just allocated by Java, tell our decoders not
to write 0s, since the memory was initialized to 0. Likewise,
when drawing to a bitmap with memory just allocated by Java, do
not erase to 0.
Depends on a change to external/skia to add the new option on
image decoders:
https://googleplex-android-review.git.corp.google.com/362663
BUG:10016979
Change-Id: I9a3dc969870f8516e7d8495fe96d0a6b8225eda2
Fixes BUG:10725383
Depends on https://googleplex-android-review.git.corp.google.com/#/c/357300/
in external/skia.
In the previous fix for BUG:8432093 and BUG:6493544
(https://googleplex-android-review.googlesource.com/#/c/346191/),
instead of calling mark on the provided input stream, we
copied the entire stream in native code (except in one case;
more details below), allowing rewind no matter how much of
the stream had been read. This was because two decoders
may rewind after reading an arbitrary amount of the stream:
SkImageDecoder_wbmp and SkImageDecoder_libjpeg.
It turns out that the jpeg decoder does not need this rewind
after arbitrary length (it is a failure recovery case, and
libjpeg has a default recovery we can use - the above referenced
CL in Skia uses the default).
Although the wbmp decoder could read any amount given a
stream with the "right" data, and then return false, such a
stream would not be a valid stream of another format, so it
is okay for this rewind to fail.
Further, the previous fix was inefficient in the common case
where the caller decodes just the bounds, resets, then decodes
the entire image (since we have copied the entire stream twice).
The copy also resulted in the crashes seen in BUG:10725383.
In this CL, buffer only the amount of input needed by
SkImageDecoder::Factory to determine the type of image decoder
needed. Do not mark the input stream provided by the caller,
so their mark (if any) can remain in tact. The new Skia class
SkFrontBufferedStream allows buffering just the beginning
of the stream.
core/jni/android/graphics/BitmapFactory.cpp:
Instead of calling GetRewindableStream (which has been removed),
call CreateJavaInputStreamAdaptor. Then wrap it in an
SkFrontBufferedStream, with a large enough buffer to determine
which type of image is used.
core/jni/android/graphics/CreateJavaOutputStreamAdaptor.h:
core/jni/android/graphics/CreateJavaOutputStreamAdaptor.cpp:
Remove mark, markSupported, and rewind. CreateJavaInputStreamAdaptor
now turns an SkStream which is not rewindable. If the caller
needs rewind that needs to be handled differently (for example,
by using SkFrontBufferedStream, as is done in BitmapFactory and
Movie.
Remove RewindableJavaStream and GetRewindableStream.
Remove code specific to ByteArrayInputStream, which makes slow
JNI calls. Instead, depend on the caller to buffer the input
in the general case. There is no reason to special case this
stream (especially since we already have decodeByteArray).
Remove CheckForAssetStream, which is now always special cased
in Java.
core/jni/android/graphics/Movie.cpp:
Call CreateJavaInputStreamAdaptor and use an SkFrontBufferedStream.
Add a native function for decoding an Asset, and remove old
call to CheckForAssetStream.
graphics/java/android/graphics/BitmapFactory.java:
Write a helper function for decoding a stream to consolidate
common code.
Buffer enough of the input so that SkImageDecoder::Factory
can rewind after having read enough to determine the type.
Unlike the old code, do NOT mark the caller's stream. This is
handled in native code. The caller's mark (if any) is left alone.
graphics/java/android/graphics/Movie.java:
Check for an Asset stream before passing to native, and
call a native function for handling the asset directly.
BUG:6493544
BUG:8432093
BUG:10725383
Change-Id: Ide74d3606ff4bb2a8c6cdbf11bae3f96696f331a
bug:10691404
Only ref the wrapped pixel refs, so that they are the single source of
correct refcount, since the wrapping pixel ref can change out from
underneath an SkBitmap.
Change-Id: I253b8737d2afdcc567a26725fa40b1d9ef0e6a92
- Deprecates SurfaceTexture.OutOfResourcesException, it wasn't used
- Make all JNI code throw only Surface.OutOfResourcesException
- Get rid of redundant SurfaceControl.OutOfResourcesException
Bug: 10566539
Change-Id: I58126260771b9ccff6a69c672ce7719b9f98138d
Reused bitmaps may gain a color table when reused, so we wrap a new
AndroidPixelRef that holds the color table around the old.
bug:10608305
Change-Id: I35288edf3158cfda21c500360ad1abdf5654af8d
Write a registration function and call it in AndroidRuntime,
which calls FindClass/GetFieldID only once per class/method.
Use NewGlobalRef for classes that will be checked against later.
BUG:10612755
Change-Id: I25541da1b7bb1cd53a1579ea84c4620e1901310f
In order to fix open source builds, change WrapJavaInputStream's
name back to CreateJavaInputStreamAdaptor.
Remove FIXME in CopyJavaInputStream, and return a more generic type,
since the more specific type was only needed by a change in external/webkit,
which is being reverted since it depends on unreleased code.
Change-Id: I89b0431e357b509a2a0c17a624b31bd49d29070f
The current stream wrapper returns a potentially incorrect
value for a call to getLength(), is typically copied into
another stream (not always in the same way), and doesn't
always take advantage of its underlying data (like when it
is an Asset). The overall goal of this CL is to provide the
caller with something that is ready to use, depending on
what is asked for. If a copy is desired, the copy is made
before being returned to the caller.
core/jni/android/graphics/Bitmap.cpp:
Include SkStream.h, since it is no longer included by
CreateJavaOutputStreamAdaptor's header file.
core/jni/android/graphics/BitmapFactory.cpp:
Pass an SkStreamRewindable to decoding functions, as Skia
decoders will be updated to only take an SkStreamRewindable
(which makes more sense because they require rewinding).
Call the more specific GetRewindableStream to get a
rewindable stream.
Remove copyAssetToStream which has been moved to Utils.
In nativeDecodeAsset, pass forcePurgeable as allowPurgeable
in doDecode. Technically the old code worked, but it checked
the BitmapOptions again.
Remove getFDSize, which is no longer used.
core/jni/android/graphics/BitmapRegionDecoder.cpp:
Remove redundant buildSkMemoryStream. nativeNewInstanceFromStream
now calls CopyJavaInputStream, which handles the copy.
Copy the Asset directly, using common code, rather than creating
an AssetStreamAdaptor to copy.
core/jni/android/graphics/CreateJavaOutputStreamAdaptor.cpp:
core/jni/android/graphics/CreateJavaOutputStreamAdaptor.h:
Provide new interfaces to access data from a Java InputStream.
The new interfaces are more specific about what type of stream
is desired.
Use forward declarations where possible.
Remove doSize, which gives a misleading answer to the question
of how long the entire stream is.
TODO: Only call FindClass etc once.
core/jni/android/graphics/Movie.cpp:
Check for an asset stream, and use it if possible. Then call
GetRewindableStream if there is not an asset.
Remove the memory leak. Call DeleteLocalRef to delete the
allocated memory.
core/jni/android/graphics/Picture.cpp:
Call the new interface.
core/jni/android/graphics/Utils.cpp:
core/jni/android/graphics/Utils.h:
Make AssetStreamAdaptor inherit from SkStreamRewindable so it
can be passed to Skia decoding functions once they require it.
Add CopyAssetToStream (moved from BitmapFactory.cpp) so it can
be used by multiple files.
graphics/java/android/graphics/BitmapFactory.java:
Remove the call to mark, which is now done natively.
Remove the BufferedInputStream. Mark/reset is now handled
by native code.
Allow decodeStream to handle a FileInputStream by using the
FileDescriptor, if it is seekable. In decodeFileDescriptor,
call nativeDecodeStream instead of decodeStream so this new
functionality will not loop.
Call setDensityFromOptions in decodeFileDescriptor.
graphics/java/android/graphics/BitmapRegionDecoder.java:
Remove the BufferedInputStream. Mark/reset is now handled
by native code.
TODO: ADD TESTS!
Requires https://googleplex-android-review.googlesource.com/#/c/344317/
BUG=https://b.corp.google.com/issue?id=8432093
Change-Id: I4419b70b3482325c98ecc673dbfc4613f1b18581
requireUnpremultiplied should be the opposite of BitmapOptions.
inPremultiplied, as in BitmapFactory.
Fixes CTS tests.
BUG=10490308
Change-Id: I21b8c057ccdc9b35c69730a7fe8c3b6802ee6dd8
Bug: 9814370
To allow WebView.capturePicture() to return a subclass, we need to
ensure the subclass is always consulted when being drawn into a canvas.
Change-Id: Ia0357f95b6fafb3ac81e6bcfaef05739e619897a
Path ops can be used to combine two paths instances in a single path
object. The following operations can be used:
- Difference
- Reverse difference
- Union
- XOR
- Intersection
To use the API:
Path p1 = createCircle();
Path p2 = createRect();
Path result = new Path();
result.op(p1, p2, Path.Op.DIFFERENCE);
This code will subtract the rectangle from the circle and generate
the resulting path in "result."
Change-Id: Ic25244665b6691a7df0b0002a09da73d937b553b
NELEM is defined many places in the framework, so this gives
android_print_PdfDocument.cpp one of them (JNIHelp.h). Without this
updating an upstream library (libskia) to remove an NELEM definition
causes this file to break.
Change-Id: Ifd033f9bd92b8902b6035ec5a8381cb9debd87ce
bug:9797004
Grants a means to reuse a bitmap's allocation for different
width/height/Config without going through
BitmapFactoryOptions.inBitmap
Change-Id: Ib62319f3bd96c451fc1636288adf06a8275b4e3d
This change adds refcounting of Res_png_9patch instances, the native
data structure used to represent 9-patches. The Dalvik NinePatch class
now holds a native pointer instead of a Dalvik byte[]. This pointer
is used whenever we need to draw the 9-patch (software or hardware.)
Since we are now tracking garbage collection of NinePatch objects
libhwui's PatchCache must keep a list of free blocks in the VBO
used to store the meshes.
This change also removes unnecessary instances tracking from
GLES20DisplayList. Bitmaps and 9-patches are refcounted at the
native level and do not need to be tracked by the Dalvik layer.
Change-Id: Ib8682d573a538aaf1945f8ec5a9bd5da5d16f74b
This change adds simple APIs that enable an Android application
to generate a PDF document by drawing content on a canvas.
Change-Id: Ibac93d7c37b01a376ce7c48238657d8c7698d588
Previously, the default hinting mode for a freshly-constructed Paint
object is equivalent to Skia's kNormal_Hinting mode, in which font
hints are respected if available. Calling
Paint.setHinting(HINTING_ON), however, is equivalent to setting
Skia's kSlight_Hinting mode, in which font hints are ignored in
favour of freetype-generated autohints.
This discrepancy is bad for a variety of reasons:
- Once Paint.setHinting() has been called, it is impossible to return
to the default hinting level.
- Calling paint.setHinting(otherPaint.getHinting()) can result in
paint having a different hinting level than otherPaint.
- Paint.setHinting(HINTING_ON) actually results in font hints being
ignored, which is perhaps the opposite of the intended behaviour.
This commit resolves these discrepancies by making HINTING_ON
correspond to Skia's kNormal_Hinting setting.
Change-Id: Iefb8e051ef53bea783e6f3be37748985ec397bc5
Bug: 9466164
This change adds simple APIs that enable an Android application
to generate a PDF document by drawing content on a canvas.
Change-Id: Iddcd126b3af37c73d99262f6b276caa07b998c1d
Also, simplifies scaling path, removing java variant - we always do
the scaling in native, which has the benefit of avoiding non-native
temporary allocations
Change-Id: I39c2219f5d77a267719629704e65611cf4388a82
bug:9194265
Instead of using custom code in skia to avoid allocations, use a
custom allocator that reuses the allocations from the inBitmap.
In order to avoid inconsistent state, the decode is done in a
separate bitmap and swapped into the existing native bitmap.
Eventually, we'd like to support inScaled=true completely avoiding
java allocations.
Change-Id: Ic4a2f2373b100a80a32c1cdebb7bcb726711c8a7
