1 /*
2  * Copyright (C) 2014 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 android.annotation.Nullable;
20 import android.content.res.AssetManager;
21 import android.graphics.fonts.FontVariationAxis;
22 import android.text.TextUtils;
23 import android.util.Log;
24 
25 import dalvik.annotation.optimization.CriticalNative;
26 
27 import libcore.util.NativeAllocationRegistry;
28 
29 import java.io.FileInputStream;
30 import java.io.IOException;
31 import java.nio.ByteBuffer;
32 import java.nio.channels.FileChannel;
33 
34 /**
35  * A family of typefaces with different styles.
36  *
37  * @hide
38  */
39 public class FontFamily {
40 
41     private static String TAG = "FontFamily";
42 
43     private static final NativeAllocationRegistry sBuilderRegistry = new NativeAllocationRegistry(
44             FontFamily.class.getClassLoader(), nGetBuilderReleaseFunc(), 64);
45 
46     private @Nullable Runnable mNativeBuilderCleaner;
47 
48     private static final NativeAllocationRegistry sFamilyRegistry = new NativeAllocationRegistry(
49             FontFamily.class.getClassLoader(), nGetFamilyReleaseFunc(), 64);
50 
51     /**
52      * @hide
53      */
54     public long mNativePtr;
55 
56     // Points native font family builder. Must be zero after freezing this family.
57     private long mBuilderPtr;
58 
FontFamily()59     public FontFamily() {
60         mBuilderPtr = nInitBuilder(null, 0);
61         mNativeBuilderCleaner = sBuilderRegistry.registerNativeAllocation(this, mBuilderPtr);
62     }
63 
FontFamily(@ullable String[] langs, int variant)64     public FontFamily(@Nullable String[] langs, int variant) {
65         final String langsString;
66         if (langs == null || langs.length == 0) {
67             langsString = null;
68         } else if (langs.length == 1) {
69             langsString = langs[0];
70         } else {
71             langsString = TextUtils.join(",", langs);
72         }
73         mBuilderPtr = nInitBuilder(langsString, variant);
74         mNativeBuilderCleaner = sBuilderRegistry.registerNativeAllocation(this, mBuilderPtr);
75     }
76 
77     /**
78      * Finalize the FontFamily creation.
79      *
80      * @return boolean returns false if some error happens in native code, e.g. broken font file is
81      *                 passed, etc.
82      */
freeze()83     public boolean freeze() {
84         if (mBuilderPtr == 0) {
85             throw new IllegalStateException("This FontFamily is already frozen");
86         }
87         mNativePtr = nCreateFamily(mBuilderPtr);
88         mNativeBuilderCleaner.run();
89         mBuilderPtr = 0;
90         if (mNativePtr != 0) {
91             sFamilyRegistry.registerNativeAllocation(this, mNativePtr);
92         }
93         return mNativePtr != 0;
94     }
95 
abortCreation()96     public void abortCreation() {
97         if (mBuilderPtr == 0) {
98             throw new IllegalStateException("This FontFamily is already frozen or abandoned");
99         }
100         mNativeBuilderCleaner.run();
101         mBuilderPtr = 0;
102     }
103 
addFont(String path, int ttcIndex, FontVariationAxis[] axes, int weight, int italic)104     public boolean addFont(String path, int ttcIndex, FontVariationAxis[] axes, int weight,
105             int italic) {
106         if (mBuilderPtr == 0) {
107             throw new IllegalStateException("Unable to call addFont after freezing.");
108         }
109         try (FileInputStream file = new FileInputStream(path)) {
110             FileChannel fileChannel = file.getChannel();
111             long fontSize = fileChannel.size();
112             ByteBuffer fontBuffer = fileChannel.map(FileChannel.MapMode.READ_ONLY, 0, fontSize);
113             if (axes != null) {
114                 for (FontVariationAxis axis : axes) {
115                     nAddAxisValue(mBuilderPtr, axis.getOpenTypeTagValue(), axis.getStyleValue());
116                 }
117             }
118             return nAddFont(mBuilderPtr, fontBuffer, ttcIndex, weight, italic);
119         } catch (IOException e) {
120             Log.e(TAG, "Error mapping font file " + path);
121             return false;
122         }
123     }
124 
addFontFromBuffer(ByteBuffer font, int ttcIndex, FontVariationAxis[] axes, int weight, int italic)125     public boolean addFontFromBuffer(ByteBuffer font, int ttcIndex, FontVariationAxis[] axes,
126             int weight, int italic) {
127         if (mBuilderPtr == 0) {
128             throw new IllegalStateException("Unable to call addFontWeightStyle after freezing.");
129         }
130         if (axes != null) {
131             for (FontVariationAxis axis : axes) {
132                 nAddAxisValue(mBuilderPtr, axis.getOpenTypeTagValue(), axis.getStyleValue());
133             }
134         }
135         return nAddFontWeightStyle(mBuilderPtr, font, ttcIndex, weight, italic);
136     }
137 
138     /**
139      * @param mgr The AssetManager to use for this context.
140      * @param path The path to the font file to load.
141      * @param cookie If available, the resource cookie given by Resources.
142      * @param isAsset {@code true} if this is from the assets/ folder, {@code false} if from
143      *            resources
144      * @param weight The weight of the font. If 0 is given, the weight and italic will be resolved
145      *            using the OS/2 table in the font.
146      * @param isItalic Whether this font is italic. If the weight is set to 0, this will be resolved
147      *            using the OS/2 table in the font.
148      * @return
149      */
addFontFromAssetManager(AssetManager mgr, String path, int cookie, boolean isAsset, int ttcIndex, int weight, int isItalic, FontVariationAxis[] axes)150     public boolean addFontFromAssetManager(AssetManager mgr, String path, int cookie,
151             boolean isAsset, int ttcIndex, int weight, int isItalic,
152             FontVariationAxis[] axes) {
153         if (mBuilderPtr == 0) {
154             throw new IllegalStateException("Unable to call addFontFromAsset after freezing.");
155         }
156         if (axes != null) {
157             for (FontVariationAxis axis : axes) {
158                 nAddAxisValue(mBuilderPtr, axis.getOpenTypeTagValue(), axis.getStyleValue());
159             }
160         }
161         return nAddFontFromAssetManager(mBuilderPtr, mgr, path, cookie, isAsset, ttcIndex, weight,
162                 isItalic);
163     }
164 
165     // TODO: Remove once internal user stop using private API.
nAddFont(long builderPtr, ByteBuffer font, int ttcIndex)166     private static boolean nAddFont(long builderPtr, ByteBuffer font, int ttcIndex) {
167         return nAddFont(builderPtr, font, ttcIndex, -1, -1);
168     }
169 
nInitBuilder(String langs, int variant)170     private static native long nInitBuilder(String langs, int variant);
171 
172     @CriticalNative
nCreateFamily(long mBuilderPtr)173     private static native long nCreateFamily(long mBuilderPtr);
174 
175     @CriticalNative
nGetBuilderReleaseFunc()176     private static native long nGetBuilderReleaseFunc();
177 
178     @CriticalNative
nGetFamilyReleaseFunc()179     private static native long nGetFamilyReleaseFunc();
180     // By passing -1 to weigth argument, the weight value is resolved by OS/2 table in the font.
181     // By passing -1 to italic argument, the italic value is resolved by OS/2 table in the font.
nAddFont(long builderPtr, ByteBuffer font, int ttcIndex, int weight, int isItalic)182     private static native boolean nAddFont(long builderPtr, ByteBuffer font, int ttcIndex,
183             int weight, int isItalic);
nAddFontWeightStyle(long builderPtr, ByteBuffer font, int ttcIndex, int weight, int isItalic)184     private static native boolean nAddFontWeightStyle(long builderPtr, ByteBuffer font,
185             int ttcIndex, int weight, int isItalic);
nAddFontFromAssetManager(long builderPtr, AssetManager mgr, String path, int cookie, boolean isAsset, int ttcIndex, int weight, int isItalic)186     private static native boolean nAddFontFromAssetManager(long builderPtr, AssetManager mgr,
187             String path, int cookie, boolean isAsset, int ttcIndex, int weight, int isItalic);
188 
189     // The added axis values are only valid for the next nAddFont* method call.
190     @CriticalNative
nAddAxisValue(long builderPtr, int tag, float value)191     private static native void nAddAxisValue(long builderPtr, int tag, float value);
192 }
193