Android and Desktop games internationalization using Java and LibGDX

原文地址:http://blog.gemserk.com/2012/05/23/android-and-desktop-games-internationalization-using-java-and-libgdx/

Recently, we had to add multiple language support for a game we aredeveloping. As you may know, Java provides classes to simplify thetask of making your application available in multiple languages. Inthis post we want to share a bit our experience when using Javalocalization classes in a LibGDX application to provide multiplelanguage support for both Android and desktop platforms.

Quick introduction

Java provides a class named ResourceBundle whichprovides a way to store resources (mainly strings) for a givenlocale, so you can ask for a string identified by a key and it willreturn the text depending the current locale. You can read thearticle JavaInternationalization: Localization withResourceBundles if you want to know more abouthow to use Java classes for internationalization. The rest of thepost assumes you know something about Locale andResourceBundle classes.

Why we don’t use Android resources

Android provides also a way to support multiple locale resourcesbut it depends on Android API, so we prefer to use the Java APIinstead which should work on all platforms.

Our experience when using Java internationalization on Android

When letting ResourceBundle to automatically load resources bundlesfrom properties files, Javaexpectsthem to be in ISO-8859-1 encoding. However, it seems Androidbehaves in a different way and expects another encoding by default.So, when resource bundles are automatically loaded in Android froman ISO-8859-1 properties file with special characters, it loadsthem wrong.

The first try

The first solution we tried to fix this was to callResourceBundle.getBundle() method using acustom Control implementationwhich creates PropertyResourceBundles usingan InputReader with the correct encoding. Here is a code example toachieve that:

public class EncodingControl extends Control {

        String encoding;

        public EncodingControl(String encoding) {
                this.encoding = encoding;
        }

        @Override
        public ResourceBundle newBundle(String baseName, Locale locale, String format, ClassLoader loader, boolean reload) 
                        throws IllegalAccessException, InstantiationException, IOException {
                String bundleName = toBundleName(baseName, locale);
                String resourceName = toResourceName(bundleName, "properties");
                ResourceBundle bundle = null;
                InputStream inputStream = null;
                try {
                        inputStream = loader.getResourceAsStream(resourceName);
                        bundle = new PropertyResourceBundle(new InputStreamReader(inputStream, encoding));
                } finally {
                        if (inputStream != null)
                                inputStream.close();
                }
                return bundle;
        }
}

After that, we customized the Control class to work with LibGDXFileHandle in order to place the properties files in the assetsfolder. Here is the final code for our Control implementation:

public class GdxFileControl extends Control {

        private String encoding;
        private FileType fileType;

        public GdxFileControl(String encoding, FileType fileType) {
                this.encoding = encoding;
                this.fileType = fileType;
        }
        
        public ResourceBundle newBundle(String baseName, Locale locale, String format, ClassLoader loader, boolean reload) 
                        throws IllegalAccessException, InstantiationException, IOException {
                // The below is a copy of the default implementation.
                String bundleName = toBundleName(baseName, locale);
                String resourceName = toResourceName(bundleName, "properties");
                ResourceBundle bundle = null;
                FileHandle fileHandle = Gdx.files.getFileHandle(resourceName, fileType);
                if (fileHandle.exists()) {
                        InputStream stream = null;
                        try {
                                stream = fileHandle.read();
                                // Only this line is changed to make it to read properties files as UTF-8.
                                bundle = new PropertyResourceBundle(new InputStreamReader(stream, encoding));
                        } finally {
                                if (stream != null)
                                        stream.close();
                        }
                }
                return bundle;
        }
}

And that can be called in this way:

       ResourceBundle.getBundle("messages", new GdxFileControl("ISO-8859-1", FileType.Internal))

That worked really well until we discovered that Android API sucksand doesn’tsupport ResourceBundle.Control before API level 9, that meansour solution works only for users with Android 2.3+. That’s aproblem since we want to support 2.0+, so we had to think anotherway to solve this.

The second try

After some tests, we discovered that if we construct aPropertyResourceBundle using an InputStream, the expected encodingis ISO-8859-1 for both desktop and Android. That means that, if weuse that specific PropertyResourceBundle constructor, we don’t haveto force the encoding. So, the new solution consists in building aPropertyResourceBundle for each locale and configuring thehierarchy ourselves by setting their parent ResourceBundle. Here isan example of what we do now:

     FileHandle rootFileHandle = Gdx.files.internal("data/messages.properties");
        FileHandle spanishFileHandle = Gdx.files.internal("data/messages_es.properties");
        ResourceBundle rootResourceBundle = new PropertyResourceBundle(rootFileHandle.read());
        ResourceBundle spanishResourceBundle = new PropertyResourceBundle(spanishFileHandle.read()) {{
                setParent(rootResourcebundle);
        }};

After that we created a map of ResourceBundles for each Locale wesupport, so we can call something like:

 ResourceBundle resourceBundle = getResourceBundle(new Locale("es"));

The good part is this solution works well for both Android anddesktop despite the Android API level (PropertyResourceBudndleseems to be supported from API Level 1). The bad part is that welost the ResourceBundle logic to automatically build the hierarchyof resources and we had to do that manually now.

Conclusion

Supporting multiple languages in an application is a way to sayusers of all around the world you care about them but translatingtext to several languages is not cheap at all, however, Javaprovides a good framework to simplify the job if you decide tosupport internationalization.

And as a side conclusion: never assume all the Java classes you areusing are implemented for the minimum Android API you aretargeting.

References

• Java Internationalization:Localization with ResourceBundles –http://java.sun.com/developer/technicalArticles/Intl/ResourceBundles/
• How to use UTF-8 in resourceproperties with ResourceBundle –http://stackoverflow.com/questions/4659929/how-to-use-utf-8-in-resource-properties-with-resourcebundle

注:

public class TestResourceBundle{ 
        public static void main(String[]args) { 
                Localelocale1 = new Locale("zh", "CN"); 
                ResourceBundleresb1 = ResourceBundle.getBundle("myres",locale1); 
                System.out.println(resb1.getString("aaa")); 

                ResourceBundleresb2 = ResourceBundle.getBundle("myres",Locale.getDefault()); 
                System.out.println(resb1.getString("aaa")); 

                Localelocale3 = new Locale("en", "US"); 
                ResourceBundleresb3 = ResourceBundle.getBundle("myres",locale3); 
                System.out.println(resb3.getString("aaa")); 
        } 
}