BlackBerry Localization sample (1)

http://us.blackberry.com/devjournals/resources/journals/sep_2006/localization.jsp

Localization is the process by which an application's user interface is
adapted to meet the default language that is currently set on a
BlackBerry^® device. The concept of localization is becoming more
important in the world of BlackBerry, as usage expands across the world.

Topics within this article include:

• What is a locale?
  
• Class ~
  ResourceBundle
  
• Class ~
  ResourceBundleFamily
  
• What is required?
  
• Putting it all together
  
  
  
• Step # 1 ~ Add Resource Header
  File
  
• Step # 2 ~ Add Resource Content
  File
  
• Step # 3 ~ Add resources keys and
  values into the resources
  
• Step # 4 ~ Editing application code
  to include support for resources

Adding
Additional Locales

A More Efficient Way

1) Create
Resource Projects

2) Confirm
the Output Filename

3) Create
an initialization file

4) Add files to appropriate
resource projects

 

There are several benefits to implementing localization within an
application:

• Text translations are more efficient.
  
• Applications can dynamically retrieve the appropriate text based on the
  user's locale.

 

Localization can be added by using the ResourceBundle and
ResourceBundleFamily classes, which are members of the net.rim.device.api.il8n
package.

In general, the resources for a particular locale are stored within a
ResourceBundle. A ResourceBundleFamily will contain a collection of
ResourceBundle objects, which groups the resources for an application.

What is a locale?

A locale represents a specific geographical, political, or cultural region
such as France, Spain or London.

---

Note: MIDP applications (MIDlets) that implement JSR-238
for localization will not currently work.

---

 

The ResourceBundle and ResourceBundleFamily classes are outlined in the next
two sections.

---

Class ~ ResourceBundle

---

Definition:

The net.rim.device.api.il8n.ResourceBundle class defines the base
functionality for locale-specific resource bundles.

Constructor:

protected ResourceBundle(Locale locale)

Constructs a new ResourceBundle instance. The parameter "Locale" is the
locale for this resource bundle.

Returns	Method	Parameter
ResourceBundleFamily	getBundle	String name

 

Description:

• Retrieves resource bundle family by name

 

Parameter:

• The name for the resource bundle family

 

Returns:

• Resource bundle family of the passed name. If the resource bundle family
  does not already exist, this method creates it for you.

 

Returns	Method	Parameter
ResourceBundleFamily	getBundle	long bundle String name

 

Description:

• Retrieves the resource bundle family by ID. If this bundle family does not
  exist, this method creates a new resource bundle family with the provided ID and
  name.

 

Parameters:

• Bundle ID
  
• Name for the resource bundle family

 

Returns:

• Resource bundle family of provided ID
  
• If it doesn't already exist, this method creates it for you

 

Throws:

• IllegalArgumentException if the name or its hash is not valid

 

Returns	Method	Parameter
ResourceBundleFamily	getBundle	long bundle String name CodeSigningKey key

 

Description:

• Retrieves the resource bundle family by ID. If this bundle family does not
  exist, this method creates a new resource bundle family with the provided ID and
  name and returns it.

 

Parameters

• Bundle ID
  
• Name for the resource bundle family
  
• Code signing key

 

Returns:

• Resource bundle family of provided ID
  
• If it doesn't already exist, this method creates it for you

 

Throws:

• IllegalArgumentException if the name or its hash is not valid

 

Returns	Method	Parameter
ResourceBundleFamily	getFamily	void

 

Description:

• Retrieves the bundle's family

 

Parameter:

• None

 

Returns:

• Resource bundle family containing this bundle

 

Returns	Method	Parameter
Locale	getLocale	void

 

Description:

• Retrieves this bundle's locale

 

Parameter:

• None

 

Returns:

• The bundle's locale
  
• Returns null if the bundle is a bundle family

 

Returns	Method	Parameter
Object	getObject	int key

 

Description:

• Retrieves resource object using a key by chaining through parent bundles.
  This method simply invokes getObject(key, true). Invoking this method on a
  derived class prompts the method to invoke this method on the enclosing bundle
  parent if the object is not found in this bundle. If the object is never found
  through the entire chain of calls on parent objects, then this method throws an
  exception.

 

Parameter:

• Key for searched-for resource object

 

Returns:

• Resource object associated with key

 

Throws:

• MissingResourceException if neither this bundle, or any enclosing parent
  bundle, contains the resource associated with the provided key.

 

Returns	Method	Parameter
Object	getObject	int key boolean searchParent

 

Description:

• Retrieves resource object by key

 

Parameters:

• Key for searched-for resource object
  
• searchParent: if true, and if this bundle does not contain the resource
  object, this method looks in the enclosing bundle parent for the object, and
  chains outwards through enclosing bundles until either the object is found, or
  the outmost bundle is reached. If false, this method stops looking after
  searching this bundle.

 

Returns:

• Resource object associated with key or null if this bundles does not contain
  the object. If searchParent was specified as true, then null gets returned only
  if this method cannot find the object in this bundle, nor any enclosing parent
  bundle.

 

Returns	Method	Parameter
String	getString	int key

 

Description:

• Retrieves string form of resource object by key. This method merely casts
  the return value of getObject(int) as a String.

 

Parameter:

• Key for searched-for resource object

 

Returns:

• String form of resource object

 

Throws:

• MissingResourceException if neither this bundle, nor any enclosing parent
  bundle, contains the resource associated with provided key

 

Returns	Method	Parameter
String[]	getStringArray	int key

 

Description:

• Retrieves string array from of a resource object by key. This method merely
  casts the return value of getObject(int) as a String array.

 

Parameter:

• Key for searched-for resource object

 

Returns:

• String array form of research object

 

Throws:

• MissingResourceException if neither this bundle, nor any enclosing parent
  bundle, contains the resource associated with the provided key.

 

Returns	Method	Parameter
Object	handleGetObject	int key

 

Description:

• Retrieves resource object handle by integer key. Subclasses must implement
  this method to return the appropriate resource object for a given key.
  

 

Parameter:

• Integer key associated with resource object

 

Returns:

• Resource object associated with integer key

 

Throws:

• MissingResourceException if the object associated with the key is not found
  

 

---

Class ~ ResourceBundleFamily

---

Definition:

The net.rim.device.api.il8n.ResourceBundleFamily class is a ResourceBundle
that contains a collection of ResourceBundles. The ResourceBundleFamily extends
ResourceBundle.

Returns	Method	Parameter
ResourceBundle	getBundle	Locale locale

 

Description:

• Retrieves bundle by locale. This method returns the resource bundle
  associated with a locale. If not present, then this method returns the closest
  parent resource, and if still not present, returns null.

 

Parameter:

• Locale owning the bundle

 

Returns:

• Bundle for provided locale, closest parent bundle, or null if no bundle (or
  enclosing bundle) found for locale

 

Returns	Method	Parameter
long	getId	void

 

Description:

• Retrieves this bundle family's ID

 

Parameter:

• None

 

Overrides:

• getId() in class ResourceBundle

 

Returns:

• ID for this bundle family

 

Returns	Method	Parameter
String	getName	void

 

Description:

• Retrieves this bundle family's name

 

Parameter:

• None

 

Returns:

• Name for this bundle family

 

Returns	Method	Parameter
Object	handleGetObject	int key

 

Description:

• Retrieves a resource object handle by integer key. This method searches in
  this bundle for the object. If it is not found, then it chains back searching
  enclosing parent bundles for the object.

 

Parameter:

• Integer key associated with resource object

 

Overrides:

• handleGetObject in class ResourceBundle

 

Returns:

• Resource object associated with integer key

 

Throws:

• MissingResourceException if the object associated with the key not found
  

 

Returns	Method	Parameter
boolean	isEmpty	void

 

Description:

• Determines if this bundle family contains no resource bundles

 

Parameter:

• None

 

Returns:

• True if this resource bundle family contains no resource bundles

 

Returns	Method	Parameter
void	put	Locale locale ResourceBundle bundle

 

Description:

• Adds a resource bundle to this bundle family

 

Parameter:

• Locale for added resource bundle. If the parent locale is not yet present,
  this method waits for it.
  
• Resource bundle to add to this family

 

Throws:

• IllegalStateException if called from the wrong module
  
• MissingResourceException if the parent resource module is not found
  

 

Returns	Method	Parameter
boolean	verify	CodeSigningKey key

 

Description:

• Determines if all resource bundles in this family are signed with provided
  key

 

Parameter:

• Code Signing key to test against

 

Returns:

• True if all bundles in this family are signed with provided key. Also
  returns true if the passed key is null.

 

---

What is required?

---

Resource files must be added into the application's project space before
implementing ResourceBundle or ResourceBundleFamily. Four file types are
required to add localization to your application:

1. Resource header file
   
   
   

   This file defines descriptive keys for each localized string. The resource
   header file should be the same name as the project with an extension of .rrh
   

   
   

       Example: AppName.rrh

   
   

   When the BlackBerry Java™ Development Environment (BlackBerry JDE) builds a
   project, it creates a resource interface with the same name as the .rrh file and
   appends "Resource".

   
   

       Example: AppNameResource.java

   
   

   The resource interface file contains references to the constants added under
   the resource header file.

   
   
   
   

   
   

   ---

   
   Note: The resource interface file is created behind the scenes
   and is not accessible in BlackBerry JDE v4.1. In previous BlackBerry JDE
   versions the resource interface file was created and placed in the workspace.
   

   ---

   
   
   

    

   
   
   
2. Resource content file (root locale)
   
   
   

   This file maps resource keys to string values for the root (or global)
   locale. It has the same name as the resource header file, except that it ends
   with an extension .rrc

   
   

       Example: AppName.rrc

   
   
   
3. Resource content file (specific locales)
   
   
   

   This resource content file maps resource keys to string values for specific
   locales (language and country). These files are given the same name as the
   resource header file, followed by an underscore (_) and the language code, and
   then optionally followed by another underscore (_) and country code.

   
   

   Example:

   
   

   
   

   
   
4. English Locale
   

   AppName_en.rrc

   
   
5. Great Britain Locale
   

   AppName_en_GB.rrc

   
   
6. French Locale
   

   AppName_fr.rrc




 




There is no restriction on how many resource content files can be added.
Please keep in mind that if you want to add Great Britain locale support, you
must add the default language locale - English.




7. Initialization file
   
   
   

   This file initializes the resource bundle mechanism. It is only required when
   the resources are compiled in a project that is separate from the main
   application project.

 

Putting it all together

In general, there are four steps to be completed when adding localization
support:

1. Add resource header file
   
2. Add resource content file
   
3. Add resources keys and values into resources created in Steps 1 and 2
   
4. Edit application code to include support for resources

 

We will start off by adding the root (or global) locale into an application
named LocalizationExApp.java and then will move into adding additional locales.

The LocalizationExApp.java is a simple application that outputs a screen
containing a title and an ObjectChoiceField.

The code for this application is shown below:

package LocalizationExample;

import net.rim.device.api.ui.*;
import net.rim.device.api.ui.component.*;
import net.rim.device.api.ui.container.*;

public class LocalizationExApp extends UiApplication
{
    InitialScreen _screen = new InitialScreen();

    public static void main(String[] args)
    {
            LocalizationExApp theApp = new LocalizationExApp();
            theApp.enterEventDispatcher();
    }

    public LocalizationExApp()
    {
        pushScreen(_screen);
    }
}

final class InitialScreen extends MainScreen
{
    LabelField _title;
    ObjectChoiceField _choiceField;
    String[] _options =
    {
        "January","February","March","April","May","June",
        "July","August","September","October","November","December"
    };

    public InitialScreen() {
        super();
        _title = new LabelField("Localization Sample");
        setTitle(_title);

        _choiceField = new ObjectChoiceField("Month", _options);
        add(_choiceField);
    }
}

The workspace for the application appears as:

For this sample, the screen title and ObjectChoiceField (label and String
array) will be changed to use resource files instead of hard-coded values within
the source code.

---

Note: The following steps assume that the BlackBerry Java
Development Environment (BlackBerry JDE) v4.0 is running, with your workspace,
project and java source files already loaded.

---

 

Step # 1 ~ Add Resource Header File

1. In the BlackBerry JDE, select "File", "New"
   
   
2. Under the "Files" tab, select "Other" from the list of available file
   formats
   
   
3. Enter a name in the "File name:" field. The file name should follow the
   proper format of the resource header file specified above. For example:
   

   [ApplicationName].rrh

   
   
4. Browse to the location of the .java source files of the application and then
   click "OK". The path should appear in the "Location" field.
   
   
   

   
   

   
   

   For this sample, the resource header filename is
   "LocalizationExApp.rrh", which corresponds to the name of the Java source file
   with the extension .rrh.

   
   
5. Click "OK"
   
6. The following prompt will be displayed:
   
   
   

   

   
   

   The package name is automatically generated within the "Add package
   information:" field. It is identical to the package statement included within
   the java source file. For this sample, the package name is
   "LocalizationExample".

   
   
7. Ensure that the package name has been populated correctly and then click
   "OK".
   
8. The resource header file will appear in the text editor containing the
   package statement specified in Step # 4
   

   Confirm that the package statement appears correctly, and then close the file
   (using the X in the top, right hand corner of the window)

   
   
9. Add the resource header file ([AppName].rrh) into the project space. To do
   this, right-click on the name of your project, and select "Add File to [Project
   Name]".
   
   
   

   
   

   
   
10. Browse to the location of the resource header file and select "*.rrh" from
    the "Files of Type:" drop-down list. Highlight the resource header file and
    select "Open".
    
    
    

    

    
    

    The resource header file appears beneath the project once added.

    
    

    
    

 

Step # 2 ~ Add Resource Content File

1. In the BlackBerry JDE, select "File", "New"
   
   
2. Under the "Files" tab, select "Other" from the list of available file
   formats
   

   Enter the name of the root resource content file in the "File name:" field.
   This name should correspond to the application name with the extension .rrc
   (i.e. [ApplicationName].rrc).

   
   

   The root locale name would be LocalizationExApp.rrc

   
   
3. Browse to the location of the source files (.java) of the application and
   then click "OK". The path should appear in the "Location" field.
   
   
   

   

   
   
4. Click "Ok"
   
   
5. The resource content file appears in the text editor without contents.
   Please leave this file empty and close the file (using the X in the top/right
   hand corner of the window). If prompted to save changes, select "Yes."
   
   
6. Add the resource content file ([AppName].rrc) into the project
   

   To do this, right-click on the name of your project, and select "Add File to
   [Project Name]"

   
   
   
   

   

   
   

   Browse to the location of the resource content file and select "*.rrc" from
   the "Files of Type:" drop-down list. Highlight the resource content file and
   select "Open."

   
   
   
   

   
   

   
   

   The resource content file is added beneath the project within the BlackBerry
   JDE. The workspace appears as shown below:

   
   
   
   

   

 

Step # 3 ~ Add resources keys and values
into the resources

In the "Files" panel, double-click on the resource header file
(LocalizationExApp.rrh). The Resource Editor window appears and looks similar to
the following window:

The Resource Editor is used to enter the resource keys and values (strings or
string arrays) for each different locale. Since only the root locale (or
resource content file) has been added, the Resource Editor only displays a tab
for "Root" (as seen in the above screen capture). If more than one locale is
added, a tab will be displayed for each one.

Each row under the headers "Keys" and "Values" defines a single resource. A
blank row is also generated at the base of the list after adding a new resource.

The "Keys" column defines the descriptive name for the resource which will be
used in the source code to retrieve the associated (localized) value. The
"Values" column displays the text or content of that particular resource.

In this sample, three resource keys/values will be added.

1. Title of the Screen<
   

   (Single Value - String)

   
   
2. ObjectChoiceField Title
   

   (Single Value - String)

   
   
3. ObjectChoiceField Values
   

   (Multiple Values - String Array)

 

In the first row, enter APPLICATION_TITLE in the "Keys" field. In the
corresponding "Values" field, enter the title of the application - "Localization
Sample".

In the second row, enter "MONTH_TITLE" in the "Keys" field. In the
corresponding "Values" field, enter the title for the ObjectChoiceField -
"Months".

In the third row, enter "MONTH_VALUES" in the "Keys" field. The value for
this resource will be different than the first two that were added because this
will become an array of values as opposed to a single string value.

When a new key/value is added, it is considered to be a single value (only
one value) by default. However, a single value resource can be converted into a
multiple value by right clicking on the resource key and select "Convert to
Multiple Values".

Click "Yes" when prompted to change the resource from a single to multiple
value. Then right-click the keys value (MONTH_VALUES) and select "Properties" to
display the "Edit Resource Line" window. This is where you can add/edit/remove
values from this multiple-value resource.

For this resource, the names of the 12 months will be added. In the field
beside the three buttons - "Add", "Edit" and "Remove" - enter "January" and then
click on the "Add" button. This should display "January" in the "Values" box.
After all months have been added, the "Edit Resource Line" window appears
similar to below:

Click "OK" after all values have been entered.

The "Resource Editor" window appears as below:

After all resource keys and values have been entered into the resource editor
file, the only remaining step is to edit the existing Java source file to
include support for localization.

Step # 4 ~ Editing application code to
include support for resources

1. Ensure that the proper package is specified at the top of the application
   source file. This package reference will determine the location of all resources
   included in the project.
   
   
   
2. Include an import statement at the top of the application source file for
   the net.rim.device.api.il8n.* package. This package contains two classes,
   ResourceBundle and ResourceBundleFamily, that are used to create
   reference/retrieve resources.
   

   import net.rim.device.api.il8n.*;

   
   
3. Create and define a ResourceBundle object.
   

   A resource bundle object will have to be created as it will contain a
   reference to all constants that have been added into the resource header/content
   file(s).

   
   

   In general, the declaration of a ResourceBundle object would appear as shown
   below:

   ResourceBundle resources = ResourceBundle.getBundle
       ([Resource Interface].BUNDLE_ID,
           [Resource Interface].BUNDLE_NAME);
   

   
   

   The ResourceBundle object is defined as:

   ResourceBundle _resources = ResourceBundle.getBundle
       (LocalizationExAppResource.BUNDLE_ID,
           LocalizationExAppResource.BUNDLE_NAME);
   

   
   

   The resource interface will have the same name as the resource header file
   (.rrh) with "Resource" appended to the end.

   
   

   The getBundle() method will retrieve the appropriate resource bundle family.
   

   
   

   The BUNDLE_ID and BUNDLE_NAME are automatically created within the resource
   interface when the BlackBerry JDE compiles the application.

   
   
4. Now that the ResourceBundle object has been created, you can retrieve the
   resources by replacing each field value with the appropriate resource.
   

   The original LabelField definition is replaced with obtaining the value from
   a resource by invoking the getString() method and referencing the
   APPLICATION_TITLE key value.

   //LabelField title = new LabelField("Localization Sample");
   LabelField title = new LabelField(_resources.getString
     (LocalizationExAppResource.APPLICATION_TITLE));
   

   
   

   We have two parts for the ObjectChoiceField (Title and Values) that will be
   replaced with resources:

   _choiceField = new ObjectChoiceField(_resources.getString
     (LocalizationExAppResource.MONTH_TITLE),
         _resources.getStringArray
     (LocalizationExAppResource.MONTH_VALUES));
   

   
   

   The multiple value key resource is retrieved by using the getStringArray()
   method.

 

The updated LocalizationExApp.java file appears as shown
below:

package LocalizationExample;

import net.rim.device.api.ui.*;
import net.rim.device.api.ui.component.*;
import net.rim.device.api.ui.container.*;
import net.rim.device.api.i18n.*;

public class LocalizationExApp extends UiApplication
{
    InitialScreen _screen = new InitialScreen();

    public static void main(String[] args)
    {
        LocalizationExApp theApp = new LocalizationExApp();
        theApp.enterEventDispatcher();
    }

    public LocalizationExApp()
    {
        pushScreen(_screen);
    }
}

final class InitialScreen extends MainScreen
{
    LabelField _title;
    ObjectChoiceField _choiceField;
    ResourceBundle _resources = ResourceBundle.getBundle
        (LocalizationExAppResource.BUNDLE_ID,
            LocalizationExAppResource.BUNDLE_NAME);

    public InitialScreen() {
        super();
        //LabelField title = new LabelField("Localization Sample");
        _title = new LabelField(_resources.getString
            (LocalizationExAppResource.APPLICATION_TITLE));
        setTitle(_title);

        // Creates a new object choice field, retrieving the field
        // title (MONTH_TITLE) and a list of months (APP_MONTHS)
        // from the resource file
        _choiceField = new ObjectChoiceField
            (_resources.getString
                (LocalizationExAppResource.MONTH_TITLE),
            _resources.getStringArray
                (LocalizationExAppResource.MONTH_VALUES));
        add(_choiceField);
    }
}

Adding Additional Locales

Now that the root locale has been added into the project/application, it is
simply a matter of adding additional resources for different locales.

Working from the sample above, additional locales - Great Britain, French and
Spanish - will be created and added into the same project.

Two extra items will have to be known prior to adding additional locales:

1. Language Code
   
2. Country Code

 

Both the language and country codes follow ISO standards. The language code
follows the IS0-639 standard and the country code follows the ISO-3166 standard.

Including the country code is optional where the language code is mandatory.
The language code, with optional country code, for additional locales will be
added into the sample.

Locale	Language Code	Country Code
English, Great Britain	en	GB
French	fr	---
Spanish	es	---

 

---

Note: We are only using the Country Code for the English,
Great Britain locale in this sample.

---

 

Each locale is represented by an associated resource content file. Each file
will be named similar to the root locale, which includes the language and
country code if necessary.

The resource content file names for the three new locales would be as
follows:

• English, Great Britain
  

  LocalizationExApp_en_GB.rrc

  
  
• French
  

  LocalizationExApp_fr.rrc

  
  
• Spanish
  

  LocalizationExApp_es.rrc

 

Since we are adding a country code to one of the locales, the project also
requires a resource content file to be added for the basic language of that
specific locale. This means is that since we are adding a locale for English,
Great Britain, we must also add a resource for English.

Four additional resources will be created and added into this sample project:

Local	English
Language Code	en
Country Code	---
Resource Content Filename	LocalizationExApp_en.rrc

 

Local	English, Great Britain
Language Code	en
Country Code	GB
Resource Content Filename	LocalizationExApp_en_GB.rrc

 

Local	French
Language Code	fr
Country Code	---
Resource Content Filename	LocalizationExApp_fr.rrc

 

Local	Spanish
Language Code	es
Country Code	---
Resource Content Filename	LocalizationExApp_es.rrc

 

The general naming syntax for these additional locales would generally be as
follows:

[ApplicationName]_[LanguageCode]_[Country Code Optional].rrc

[ApplicationName]

• Name of Application Source

 

[LanguageCode]

• Language Code of the locale

 

[CountryCode]

• Country Code of the locale (Optional parameter)

 

Country Code of the locale (Optional parameter)

Now that file naming conventions for the additional locales are understood,
we can move into creating and adding additional locales into the project.

The following steps must be followed to add resource content files. These
steps must be repeated for each resource that is created and added. In this
case, these steps will be repeated four times (English, English GB, French and
Spanish) using the files names defined above.

To create these additional locales, follow the same steps that were described
when creating the root locale above (Step # 2 - Add Resource Content File),
using the file naming convention described earlier.

After adding the locales, the workspace tree structure will appears as shown
below:

Double-click on the resource header file. The resource header file will
create additional tabs for each locale that has been added. This acts as a
centralized location to add resource keys/values. The sample file,
LocalizationExApp.rrh, appears as shown below:

For each locale added, the resource keys that were added into the root locale
will automatically be generated in the additional locales with blank values.

Please note that a root locale is required for any application that will use
localization. The root locale acts as a global locale and will be used by
default if the other locales are not supported on the BlackBerry device.

To add the content or values into each key value for each locale, follow the
steps outlined in Step # 3 - Add resource keys and values into the resources.

In addition to having the resources read by the application, you can also
localize the application name that appears under the icon on the main ribbon of
the BlackBerry device. To do this, right-click on the project name, select
"Properties", and then select the "Resources" tab.

Select the "Title Resource Available" check box. In the "Resource Bundle:"
and "Title Id" drop-down lists, select the correct resource file and key for the
application title.

No extra code is required within your application to support the additional
locales. Once the application has been installed onto a BlackBerry device, the
appropriate locale will be selected by default, based on the language that the
device is set to. To find out the current language on the BlackBerry device,
view Options - Languages.

---

Note: The wording of "Options - Language" will change based
on the localization of the BlackBerry device.

---

 

A More Efficient Way

If multiple locales are being implemented or maintained for an application,
it can be more efficient to add resource files into their own project based on
the locale. This can be done as follows:

The following steps use the sample developed in the previous steps, but all
resource files were removed from the project before worked was started.

1) Create Resource Projects

Add a new project into the existing workspace for each resource bundle or
locale, including one for the root locale. The project names should match the
names of the resource content files, except that a double underscore should be
inserted prior to including the language code.

The general naming format is as follows:

[AppName]__[Language Code].jdp

... or if including a country code:

[AppName]__[Language Code]_[Country Code].jdp

For example, the resource content file for the English locale is named
"LocalizationExApp_en.rrc". The project will be named
"LocalizationExApp__en.jdp".

Once all resource projects have been added, the workspace should appear as
shown below:

2) Confirm the Output Filename

Confirm each "Output File Name" associated with each project added in Step #
1.

Right-click on the project name and select "Properties". On the project
properties window, click on the "Build" tab. The first field listed is the
Output File Name and should be the same name as the project without the file
extension.

Example:

The Output File Name for the LocalizationExApp__en_GB project will appear as
follows:

3) Create an initialization file

The BlackBerry JDE provides a built-in initialization mechanism. As such, you
will be required to create a initialization class with an empty main() for each
resource project that is created.

The code that appears within this initialization class is:

package LocalizationExample;

import net.rim.device.api.i18n.*;

public class init  {
    public static void main (String[] args) { }
}

---

Note: The package name should be changed to reflect the
correct name of your application's package.

---

 

4) Add files to
appropriate resource projects

The last step is adding the appropriate resource files and initialization
files into the project, then making sure that the project is properly set up for
deployment.

• Add the initialization file created in Step # 3 into all resource projects
  
• Add the resource header file (.rrh) to the application and all resource
  projects
  
• Under each resource project, right-click on the resource header file name
  (.rrh) and select "Properties"
  
• Check "Dependency Only. Do not build." as shown in the screen capture below:
  
  
  
  

  

  
  
• Add each resource content file (.rrc) into its appropriate resource project
  

  Right-click on each resource project name and select "Properties"

  
  

  On the resource project name property window, select the "Application" tab
  

  
  

  Change the "Project Type:" to be a "Library"

  
  

  Click "OK"

 

Now the application has been localized using a more efficient method. When
finished, the workspace is divided into six projects, as shown below:

Since each project that was created above will compile into its own cod file,
you can edit the jad file for the application project to include references to
all cod files. This will make the installation or wireless download process much
simpler.

Application deployment can occur wirelessly or by using the BlackBerry
Desktop Manager.

For further information on deployment, please refer to the Enterprise and WAP Deployment guides found under
BlackBerry Java Development Environment.