1/*
2 * Copyright (C) 2008-2012 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
17package android.renderscript;
18
19import java.io.File;
20import java.io.IOException;
21import java.io.InputStream;
22import java.util.HashMap;
23import java.util.Map;
24
25import android.os.Environment;
26
27import android.content.res.AssetManager;
28import android.content.res.Resources;
29import android.util.Log;
30import android.util.TypedValue;
31
32/**
33 * @deprecated in API 16
34 * <p>This class gives users a simple way to draw hardware accelerated text.
35 * Internally, the glyphs are rendered using the Freetype library and an internal cache of
36 * rendered glyph bitmaps is maintained. Each font object represents a combination of a typeface,
37 * and point size. You can create multiple font objects to represent styles such as bold or italic text,
38 * faces, and different font sizes. During creation, the Android system quieries device's screen DPI to
39 * ensure proper sizing across multiple device configurations.</p>
40 * <p>Fonts are rendered using screen-space positions and no state setup beyond binding a
41 * font to the Renderscript is required. A note of caution on performance, though the state changes
42 * are transparent to the user, they do happen internally, and it is more efficient to
43 * render large batches of text in sequence. It is also more efficient to render multiple
44 * characters at once instead of one by one to improve draw call batching.</p>
45 * <p>Font color and transparency are not part of the font object and you can freely modify
46 * them in the script to suit the user's rendering needs. Font colors work as a state machine.
47 * Every new call to draw text uses the last color set in the script.</p>
48 **/
49public class Font extends BaseObj {
50
51    //These help us create a font by family name
52    private static final String[] sSansNames = {
53        "sans-serif", "arial", "helvetica", "tahoma", "verdana"
54    };
55
56    private static final String[] sSerifNames = {
57        "serif", "times", "times new roman", "palatino", "georgia", "baskerville",
58        "goudy", "fantasy", "cursive", "ITC Stone Serif"
59    };
60
61    private static final String[] sMonoNames = {
62        "monospace", "courier", "courier new", "monaco"
63    };
64
65    private static class FontFamily {
66        String[] mNames;
67        String mNormalFileName;
68        String mBoldFileName;
69        String mItalicFileName;
70        String mBoldItalicFileName;
71    }
72
73    private static Map<String, FontFamily> sFontFamilyMap;
74
75    /**
76     * @deprecated in API 16
77     */
78    public enum Style {
79        /**
80         * @deprecated in API 16
81         */
82        NORMAL,
83        /**
84         * @deprecated in API 16
85         */
86        BOLD,
87        /**
88         * @deprecated in API 16
89         */
90        ITALIC,
91        /**
92         * @deprecated in API 16
93         */
94        BOLD_ITALIC;
95    }
96
97    private static void addFamilyToMap(FontFamily family) {
98        for(int i = 0; i < family.mNames.length; i ++) {
99            sFontFamilyMap.put(family.mNames[i], family);
100        }
101    }
102
103    private static void initFontFamilyMap() {
104        sFontFamilyMap = new HashMap<String, FontFamily>();
105
106        FontFamily sansFamily = new FontFamily();
107        sansFamily.mNames = sSansNames;
108        sansFamily.mNormalFileName = "Roboto-Regular.ttf";
109        sansFamily.mBoldFileName = "Roboto-Bold.ttf";
110        sansFamily.mItalicFileName = "Roboto-Italic.ttf";
111        sansFamily.mBoldItalicFileName = "Roboto-BoldItalic.ttf";
112        addFamilyToMap(sansFamily);
113
114        FontFamily serifFamily = new FontFamily();
115        serifFamily.mNames = sSerifNames;
116        serifFamily.mNormalFileName = "DroidSerif-Regular.ttf";
117        serifFamily.mBoldFileName = "DroidSerif-Bold.ttf";
118        serifFamily.mItalicFileName = "DroidSerif-Italic.ttf";
119        serifFamily.mBoldItalicFileName = "DroidSerif-BoldItalic.ttf";
120        addFamilyToMap(serifFamily);
121
122        FontFamily monoFamily = new FontFamily();
123        monoFamily.mNames = sMonoNames;
124        monoFamily.mNormalFileName = "DroidSansMono.ttf";
125        monoFamily.mBoldFileName = "DroidSansMono.ttf";
126        monoFamily.mItalicFileName = "DroidSansMono.ttf";
127        monoFamily.mBoldItalicFileName = "DroidSansMono.ttf";
128        addFamilyToMap(monoFamily);
129    }
130
131    static {
132        initFontFamilyMap();
133    }
134
135    static String getFontFileName(String familyName, Style style) {
136        FontFamily family = sFontFamilyMap.get(familyName);
137        if(family != null) {
138            switch(style) {
139                case NORMAL:
140                    return family.mNormalFileName;
141                case BOLD:
142                    return family.mBoldFileName;
143                case ITALIC:
144                    return family.mItalicFileName;
145                case BOLD_ITALIC:
146                    return family.mBoldItalicFileName;
147            }
148        }
149        // Fallback if we could not find the desired family
150        return "DroidSans.ttf";
151    }
152
153    Font(int id, RenderScript rs) {
154        super(id, rs);
155    }
156
157    /**
158     * @deprecated in API 16
159     * Takes a specific file name as an argument
160     */
161    static public Font createFromFile(RenderScript rs, Resources res, String path, float pointSize) {
162        rs.validate();
163        int dpi = res.getDisplayMetrics().densityDpi;
164        int fontId = rs.nFontCreateFromFile(path, pointSize, dpi);
165
166        if(fontId == 0) {
167            throw new RSRuntimeException("Unable to create font from file " + path);
168        }
169        Font rsFont = new Font(fontId, rs);
170
171        return rsFont;
172    }
173
174    /**
175     * @deprecated in API 16
176     */
177    static public Font createFromFile(RenderScript rs, Resources res, File path, float pointSize) {
178        return createFromFile(rs, res, path.getAbsolutePath(), pointSize);
179    }
180
181    /**
182     * @deprecated in API 16
183     */
184    static public Font createFromAsset(RenderScript rs, Resources res, String path, float pointSize) {
185        rs.validate();
186        AssetManager mgr = res.getAssets();
187        int dpi = res.getDisplayMetrics().densityDpi;
188
189        int fontId = rs.nFontCreateFromAsset(mgr, path, pointSize, dpi);
190        if(fontId == 0) {
191            throw new RSRuntimeException("Unable to create font from asset " + path);
192        }
193        Font rsFont = new Font(fontId, rs);
194        return rsFont;
195    }
196
197    /**
198     * @deprecated in API 16
199     */
200    static public Font createFromResource(RenderScript rs, Resources res, int id, float pointSize) {
201        String name = "R." + Integer.toString(id);
202
203        rs.validate();
204        InputStream is = null;
205        try {
206            is = res.openRawResource(id);
207        } catch (Exception e) {
208            throw new RSRuntimeException("Unable to open resource " + id);
209        }
210
211        int dpi = res.getDisplayMetrics().densityDpi;
212
213        int fontId = 0;
214        if (is instanceof AssetManager.AssetInputStream) {
215            int asset = ((AssetManager.AssetInputStream) is).getAssetInt();
216            fontId = rs.nFontCreateFromAssetStream(name, pointSize, dpi, asset);
217        } else {
218            throw new RSRuntimeException("Unsupported asset stream created");
219        }
220
221        if(fontId == 0) {
222            throw new RSRuntimeException("Unable to create font from resource " + id);
223        }
224        Font rsFont = new Font(fontId, rs);
225        return rsFont;
226    }
227
228    /**
229     * @deprecated in API 16
230     * Accepts one of the following family names as an argument
231     * and will attempt to produce the best match with a system font:
232     *
233     * "sans-serif" "arial" "helvetica" "tahoma" "verdana"
234     * "serif" "times" "times new roman" "palatino" "georgia" "baskerville"
235     * "goudy" "fantasy" "cursive" "ITC Stone Serif"
236     * "monospace" "courier" "courier new" "monaco"
237     *
238     * Returns default font if no match could be found.
239     */
240    static public Font create(RenderScript rs, Resources res, String familyName, Style fontStyle, float pointSize) {
241        String fileName = getFontFileName(familyName, fontStyle);
242        String fontPath = Environment.getRootDirectory().getAbsolutePath();
243        fontPath += "/fonts/" + fileName;
244        return createFromFile(rs, res, fontPath, pointSize);
245    }
246
247}
248