(In case you're wondering: per-view internationalization is the ability to maintain i18n.properties files, which contain translations for human readable texts together with the view code wherein these texts appear, rather maintaining just one giant i18.properties file that contains the translations for any and all internationalized texts that appear throughout the application. I think the benefits of this idea are clear from a developer's point of view. If you're interested in more information about this concept, then please check out the two blog posts I wrote prior)

Per-view i18n and inheritance

The reason for me to revisit the topic is that I found that the method I use to figure out which i18n.properties files to load, doesn't work very well when you're using inheritance. In UI5, inheritance is achieved by calling the extend-method on the constructor you want to inherit from.

To understand why it doesn't work well, we should first define the scope and the desired behavior.

In my case, I'm using inheritence to build controllers for views that are a lot like other existing views, but with some additional features. Most if not all of the behavior (and texts) of the existing view should be copied, and I'm managing that copy by extending the controller of the existing view. It's just that we need some extra things in the view, and these extra things might bring their own internationalization texts along.

So, what we really need is to include not only the i18n files for the extended controller, we also need to load any i18n files that might be created for the views managed by the superclasses of the extended controller. We need to mind the order too: the extended view might choose to override some of the texts defined by a superclass, so the i18n texts that are closer in the chain of inheritance should be given precedence.

A Per-view i18n solution that works with inheritance

The following code will solve this problem:

_initI18n: function(){
//first, check if we already constructed the i18n model for this class
if (this.constructor._i18Model) {
//we did! Don't do all that work again, just use the existing one.
this.setModel(this.constructor._i18Model, i18n);
return;
}
//check if the view and controller are in the same directory.
//if they are not, then we need to take the possibility into account
//that the view and the controller might both have their own i18n files.
var stack = [];
var controllerClass = this.getMetadata();
var viewName = this.getView().getViewName();
if (controllerClass.getName() !== viewName) {
//if the view name is different from controller name,
//then we assume the view may have its own i18n
//that overrides those of the controller
stack.push(viewName);
}
//walk the chain of inheritance up to sap.ui.core.mvc.Controller
//store each superclass at the front of the stack
var className, rootControllerClassName = "sap.ui.core.mvc.Controller";
while (true) {
className = controllerClass.getName();
if (className === rootControllerClassName) {
break;
}
stack.unshift(className);
controllerClass = controllerClass.getParent();
}
//walk the stack and create a resourcebundle for each class
//use it to enhance this class' i18n model.
stack.forEach(function(className){
var bundleData;
if (window[className] && window[className]._i18Model) {
bundleData = window[className]._i18Model.getResourceBundle();
}
else {
className = className.split(".");
//snip off the local classname to get the directory name
className.pop();
//add i18n to make the i18n directory name
className.push(i18n);
//add i18n to point to the i18n.properties file(s)
className.push(i18n);
bundleData = {bundleName: className.join(".")};
}
var i18nModel = this.getModel(i18n);
if (i18nModel) {
i18nModel.enhance(bundleData);
}
else {
i18nModel = new ResourceModel(bundleData);
this.setModel(i18nModel, i18n);
}
}.bind(this));
//cache the i18n model for new instances of this class.
this.constructor._i18Model = this.getModel(i18n);
}

Note that this code replaces the _initI18n-method that appeared in my prior blog posts on this topic. It is also assumed that this method sits in some abstract base controller, which you'll extend to create actual concrete controllers for your views.

Here are a couple of highlights that explain the new and improved _initI18N-method:

Examining the entire chain of inheritance, up until sap.ui.core.mvc.Controller. This is achieved with this snippet:

The subsequenct forEach-iteration of the stack then constructs the resource bundle to enhance the i18n model in the usual way.

Note that names of superclasses that are "higher up" in the hierarchy (or put another way: more basal) are stacked in front of subclasses. This way, the forEach-array method will encounter the class names in the desired order, allowing the subclasess to override texts added by superclasses.

Distinguish between texts defined by the view and the controller.

Admittedly this scenario is quite rare, but if the controller and view each define their own i18n files, then we'd like to enhance our i18n model with files from both resourcebundles. I somehwat arbitrarily decided that in this case, the view's texts should probably override those of the controller.

I achieve this with this piece of code:

var stack = [];
var controllerClass = this.getMetadata();
var viewName = this.getView().getViewName();
if (controllerClass.getName() !== viewName) {
//if the view name is different from controller name,
//then we assume the view may have its own i18n
//that overrides those of the controller
stack.push(viewName);
}

In other words, the view name is placed as very last item of the stack; if it differs from the controller name, then the controller name appears directly before it, making the view resource bundle the last to enhance our i18n model.

Caching the i18n model at the class level, so that every instance may reuse it.

While I fixed the inheritance issue, it occurred to me that all instances of the controller would go through their own cycle of building the i18n model. Since the i18nmodel deals almost only with static texts, it seemed wasteful to repeat all that work for each instance. We can simply store the i18n model as a property of the constructor, and retrieve it any time we're creating a new instance.

This is achieved with the very first and last bits of the _initI18n-method:

//first, check if we already constructed the i18n model for this class
if (this.constructor._i18Model) {
//we did! Don't do all that work again, just use the existing one.
this.setModel(this.constructor._i18Model, i18n);
return;
}
...
...
...
//cache the i18n model for new instances of this class.
this.constructor._i18Model = this.getModel(i18n);