1 /*
2  * Copyright (C) 2011 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 package android.graphics;
18 
19 import com.android.layoutlib.bridge.Bridge;
20 import com.android.layoutlib.bridge.impl.DelegateManager;
21 import com.android.ninepatch.NinePatchChunk;
22 import com.android.resources.Density;
23 import com.android.tools.layoutlib.annotations.LayoutlibDelegate;
24 
25 import android.annotation.Nullable;
26 import com.android.layoutlib.bridge.util.NinePatchInputStream;
27 import android.graphics.BitmapFactory.Options;
28 import android.graphics.Bitmap_Delegate.BitmapCreateFlags;
29 
30 import java.io.FileDescriptor;
31 import java.io.IOException;
32 import java.io.InputStream;
33 import java.util.EnumSet;
34 import java.util.Set;
35 
36 /**
37  * Delegate implementing the native methods of android.graphics.BitmapFactory
38  *
39  * Through the layoutlib_create tool, the original native methods of BitmapFactory have been
40  * replaced by calls to methods of the same name in this delegate class.
41  *
42  * Because it's a stateless class to start with, there's no need to keep a {@link DelegateManager}
43  * around to map int to instance of the delegate.
44  *
45  */
46 /*package*/ class BitmapFactory_Delegate {
47 
48     // ------ Native Delegates ------
49 
50     @LayoutlibDelegate
nativeDecodeStream(InputStream is, byte[] storage, @Nullable Rect padding, @Nullable Options opts, long inBitmapHandle, long colorSpaceHandle)51     /*package*/ static Bitmap nativeDecodeStream(InputStream is, byte[] storage,
52             @Nullable Rect padding, @Nullable Options opts, long inBitmapHandle,
53             long colorSpaceHandle) {
54         Bitmap bm = null;
55 
56         Density density = Density.MEDIUM;
57         Set<BitmapCreateFlags> bitmapCreateFlags = EnumSet.of(BitmapCreateFlags.MUTABLE);
58         if (opts != null) {
59             density = Density.getEnum(opts.inDensity);
60             if (opts.inPremultiplied) {
61                 bitmapCreateFlags.add(BitmapCreateFlags.PREMULTIPLIED);
62             }
63             opts.inScaled = false;
64         }
65 
66         try {
67             if (is instanceof NinePatchInputStream) {
68                 NinePatchInputStream npis = (NinePatchInputStream) is;
69                 npis.disableFakeMarkSupport();
70 
71                 // load the bitmap as a nine patch
72                 com.android.ninepatch.NinePatch ninePatch = com.android.ninepatch.NinePatch.load(
73                         npis, true /*is9Patch*/, false /*convert*/);
74 
75                 // get the bitmap and chunk objects.
76                 bm = Bitmap_Delegate.createBitmap(ninePatch.getImage(), bitmapCreateFlags,
77                         density);
78                 NinePatchChunk chunk = ninePatch.getChunk();
79 
80                 // put the chunk in the bitmap
81                 bm.setNinePatchChunk(NinePatch_Delegate.serialize(chunk));
82 
83                 if (padding != null) {
84                     // read the padding
85                     int[] paddingArray = chunk.getPadding();
86                     padding.left = paddingArray[0];
87                     padding.top = paddingArray[1];
88                     padding.right = paddingArray[2];
89                     padding.bottom = paddingArray[3];
90                 }
91             } else {
92                 // load the bitmap directly.
93                 bm = Bitmap_Delegate.createBitmap(is, bitmapCreateFlags, density);
94             }
95         } catch (IOException e) {
96             Bridge.getLog().error(null, "Failed to load image", e, null);
97         }
98 
99         return bm;
100     }
101 
102     @LayoutlibDelegate
nativeDecodeFileDescriptor(FileDescriptor fd, Rect padding, Options opts, long inBitmapHandle, long colorSpaceHandle)103     /*package*/ static Bitmap nativeDecodeFileDescriptor(FileDescriptor fd,
104             Rect padding, Options opts, long inBitmapHandle, long colorSpaceHandle) {
105         if (opts != null) {
106             opts.inBitmap = null;
107         }
108         return null;
109     }
110 
111     @LayoutlibDelegate
nativeDecodeAsset(long asset, Rect padding, Options opts, long inBitmapHandle, long colorSpaceHandle)112     /*package*/ static Bitmap nativeDecodeAsset(long asset, Rect padding, Options opts,
113             long inBitmapHandle, long colorSpaceHandle) {
114         if (opts != null) {
115             opts.inBitmap = null;
116         }
117         return null;
118     }
119 
120     @LayoutlibDelegate
nativeDecodeByteArray(byte[] data, int offset, int length, Options opts, long inBitmapHandle, long colorSpaceHandle)121     /*package*/ static Bitmap nativeDecodeByteArray(byte[] data, int offset,
122             int length, Options opts, long inBitmapHandle, long colorSpaceHandle) {
123         if (opts != null) {
124             opts.inBitmap = null;
125         }
126         return null;
127     }
128 
129     @LayoutlibDelegate
nativeIsSeekable(FileDescriptor fd)130     /*package*/ static boolean nativeIsSeekable(FileDescriptor fd) {
131         return true;
132     }
133 
134     /**
135      * Set the newly decoded bitmap's density based on the Options.
136      *
137      * Copied from {@link BitmapFactory#setDensityFromOptions(Bitmap, Options)}.
138      */
139     @LayoutlibDelegate
setDensityFromOptions(Bitmap outputBitmap, Options opts)140     /*package*/ static void setDensityFromOptions(Bitmap outputBitmap, Options opts) {
141         if (outputBitmap == null || opts == null) return;
142 
143         final int density = opts.inDensity;
144         if (density != 0) {
145             outputBitmap.setDensity(density);
146             final int targetDensity = opts.inTargetDensity;
147             if (targetDensity == 0 || density == targetDensity || density == opts.inScreenDensity) {
148                 return;
149             }
150 
151             // --- Change from original implementation begins ---
152             // LayoutLib doesn't scale the nine patch when decoding it. Hence, don't change the
153             // density of the source bitmap in case of ninepatch.
154 
155             if (opts.inScaled) {
156             // --- Change from original implementation ends. ---
157                 outputBitmap.setDensity(targetDensity);
158             }
159         } else if (opts.inBitmap != null) {
160             // bitmap was reused, ensure density is reset
161             outputBitmap.setDensity(Bitmap.getDefaultDensity());
162         }
163     }
164 }
165