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