How do you change the default language used by your project without doing localization?
What if I want my app to be in Japanese or Italian? Is it enough to just use Japanese or Italian texts? How do I change the language displayed on iTunes to say that it's in Japanese or Italian?
Generally, the resources that you put in the main folder are assumed to be in the Default language, which is set in iTunes Connect when you add or edit the application. The setting is on the Application page and if it's not correctly set after adding it, click the Edit at the top of the page to be able to change it with the drop-down menu.
If you're going to localize at all, you'll want to make sure to change the localization native language, you'll need to change the key in the Info.plist corresponding to Localization native development region (a.k.a. CFBundleDevelopmentRegion in raw form) to match the language you are using for the raw files. The value of the tag should match the original localization language directory base (so en if you have an english lproj directory named en.lproj). This language will be used in the event that one of the other localizations is missing for the specific resource. Recommendations these days point to using the 2-letter version of the language (i.e. en instead of English, jp instead of Japanese, etc) as best-practice.
If you're building a Japanese-only app, you could just put all the resources in the top level. If you're going to have Japanese and any other language, you should put the language-specific Japanese resources in jp.lproj and set the CFBundleDevelopmentRegion to jp. Any unlocalized resources (standard images, etc.) can be stored in the main application folder.
By the way, same general rules in OS X as well, except that wherever I mentioned "main application folder" above, the files would be within the Resources folder.
Related
I'm writing this question because a lot of information on Stackoverflow (and even Apple's developer website) about this topic is unfortunately partially outdated:
I want to support multiple languages in my Xcode 12.5/Swift 5/iOS 12.3+ app: German as the default language and English as a "fallback".
Currently the "Info" tab lists two "Localization" languages:
The "Localization" section of the File Inspector for both my Main.storyboard and LaunchScreen.storyboard file look like this (by default):
"Base" is checked and that's why the first screenshot shows 2 files for it.
The language in Info.plist is set to the following:
So far I haven't touched the actual localization settings yet and I've been using the same language for every label,... in XIB (which is probably saved in "Base").
According to Apple's old Localization Guide, "Base" is the default language that is used, as long as it's included in the user's language settings (so in my case: German). The "Developer Language" is the "fallback" language that is used if the user's language settings don't include the base language (in my case: English). This Q&A page also says:
If you adopt Base Localization, make sure that the value of
CFBundleDevelopmentRegion matches the language used by your content in
the Base.lproj folder.
... and in this guide enabling the base localization for "English - Development Language" for both storyboards adds 2 localized files to it, without actually adding another ("Base") localization to the list. As you can see on my first screenshot, "Base" and "Development" are separate list entries, which wasn't the case in earlier Xcode versions.
My first question is: Did I understand all of this correctly? It's a bit confusing that the quote sees "Base" and "Development Language" as the same thing, even though you can of course have a default language that isn't the "fallback" language.
The same Q&A I linked above also goes into detail about regional versions of a specific language:
If my app supports "German" (language code: "de") but the user's language settings only list e.g. Austrian German ("de_AT"), then the app is still going to set its own language to German. Let's say I want to use Swiss German (de_CH) as the default language but the user only picked Austrian German ("de_AT") in his settings, does this still work the same way? Should you rather set your app's default language to the regular non-regional language (German = "de") instead, even if the labels,... use e.g. Swiss German words?
How do I change the "Base" language to German (let's say, "de_CH") and also make it appear as that in the list, while using English ("en") as the "fallback"? I did find a similar question but unfortunately the steps described in the answer don't work the same way in Xcode 12.5. anymore.
What I wanted to achieve:
Support English but use German as the default language that is also used if the user's language settings don't include English or German.
How I achieved this in Xcode 12.5:
Add "German (de)" to the "Localizations" list via the little "+" button. In the new Choose files and reference language to create German localization pop-up every storyboard file should already be ticked by default. This adds .strings (German) localization files for all storyboards in the Project Navigator on the left:
In Main.storyboard's File Inspector tick the "English" box in the "Localization" section (this might take a while). This adds an additional Main.strings (English) file in the Project Navigator. Repeat this step for each storyboard, including the launch screen.
To change the "Development Language", which is the language the app uses by default and also if it doesn't support any of the languages the user set in their device's language settings, close Xcode, then open the project's .xcodeproj file with a text editor (I used BBEdit, which is free). There should be a list of files, including project.pbxproj. Open it and set developmentRegion (= development language) to the language code of the language that you added in step 1, so in my case "de". Do not use a different code (e.g. add "German (de)" but set it to "de_CH") because that's going to create an additional localization.
There are now two ways to finish this part of localization:
A. Leave it as is. Changes in storyboard aren't going to affect any of the .strings files. Advantage: The text can be edited directly (without using storyboard), which is useful if you aren't the person who's working on the translations. Disadvantage: You can't quickly see and test the changes to a translation in storyboard but have to run the app in the simulator or on an actual device.
B. Use the default language as "Base" language: Untick "German" for every storyboard and hit "Remove" in the pop-up, which removes the localizations in the list. This way changes to the storyboard affect the default language, which makes it easier to test changes.
I used version B:
Important:
These .strings files are only used for storyboards! If you also want to set localized text at runtime using NSLocalizedString (e.g. for an error dialog), then you have to add an additional Localizable.strings file (more details here):
File - New - File - Strings File - Call it Localizable.strings
Click "Localize" in its File Inspector and pick one of the languages you want to use in code.
Afterwards, also in the File Inspector, you can tick the other languages in the "Localization" section (including the development one).
Bonus infos:
You can change the app language of the simulator through the scheme:
Product - Scheme - Edit Scheme - Run (left side) - Options tab (right side) - App Language
You can also show a preview of the currently selected UIViewController and change its displayed language without starting a simulator:
Editor - Preview - In the new preview window on the right there's a button in the bottom right
Disclaimer: I found this solution by testing different things, as there's currently no tutorial for this (using the latest Xcode version). If this is not the "right" way to do localization, please post your own answer and I'll check it out.
I'm trying to account for both English and Georgian and an app I'm developing. I had added the localization language to the project, have all the storyboard languages setup and the strings files.
I now want to test to see if the text translates correctly.
However, when I go to Edit Scheme and find the application language drop down it doesn't have Georgian.
When I added the localization in the project settings I could go to a More menu that had LOADS of languages. Why does this not exist in the Application Language drop down in the scheme settings?
EDIT:
Tried the solution below by adding language and locale as arguments:
I have what I believe is the correct setup for translating strings depending on the language of the phone etc.
The Xcode scheme Debug options only include a subset of languages plus pseudolanguages for testing. However, there are workarounds.
If you want to see if text translates correctly, do one of the following:
Go to your scheme's Arguments tab and add the AppleLanguages and AppleLocale to the "Arguments Passed On Launch" section.
For example, to select the Georgian language and the Georgian region, you'd add:
-AppleLanguages "(ka-GE)"
-AppleLocale "GEO"
or:
On the device or simulator, set the region and language in the device's Preferences and then run your app.
More here: Internationalization and Localization Guide
Note that the ISO language code for Georgia is "ka-GE", not "ge". You should have "ka-GE.lproj" as your localization folder name.
The language code comes from the ISO codes here: ISO 639-2 codes, and the region code comes from these: ISO_3166-2 codes
One other thing I just noticed is that your string translation files are called "Localize.strings". The default filename is "Localizable.strings" and if you're calling NSLocalizedString without providing an explicit file name in the optional table parameter, that's what iOS looks for. So, you'll probably need to rename your translation files for things to work.
I am developing an iOS app targeted almost exclusively at a Japanese audience, with the possibility of a small portion of english-speaking users.
All storyboards and xibs are being designed with Japanese strings, and localization into English should take place at a later stage.
From the beginning, the Project's Info/Localizations section in Xcode reads:
(The two files are, of course, "Main.storyboard" and "LaunchScreen.xib")
Because "English" is already added (as the development language), I can not click the "+" button and add it as a localization. I could add 'Japanese' instead, but I want it to be the Development Language, not just some (secondary) localization.
Also, and in an apparent contradiction with the above, The Target's Info.plist file reads:
When I select either of the localized files (Main.storyboard and LaunchScreen.xib) in the Project Navigator, and check the file inspector, the 'Localization' section reads:
...which seems to suggest that the existing, Japanese files (.xib and .storyboard) are the 'Base' and checking 'English' will add support for that language too (The pull-down menu seems to indicate that I can chose between using a strings file or a dedicated duplicate of the storyboard. I am inclined to believe the strings approach is better).
...So, how should I proceed?
A. Check the 'English' box in the File inspector / Localization section?
This creates an en.lproj folder and adds a strings file inside it that I should translate later, I guess. This effectively seems to treat my existing Interface Builder files (populated with Japanese labels) as 'Base', and provide for localization into English through the strings file created (if I understand correctly). However, English as the Development Language in the Project settings remains somehow unsettling...
B. Remove English and instead add Japanese in the Project/Info/Localizations pane?
This will make Japanese the Development Language, and I can re-add English as a localization afterwards. But for some reason, if I do this Japanese will not be treated as 'Base' language, and (unnecessary) string files will be also added for Japanese, not just for English.
EDIT: I found this question, which somehow provides a 'fix' for the option B above.
OK, this is what I settled for (but I will still accept better/smarter answers):
I did as suggested by the question I mentioned before, and edited the Xcode project file to force Japanese as the "Development Language":
developmentRegion = English;
hasScannedForEncodings = 0;
knownRegions = (
en,
Base,
);
becomes:
developmentRegion = Japanese;
hasScannedForEncodings = 0;
knownRegions = (
en,
ja,
Base,
Next, for the storyboards/xibs I want to localize, I will check the 'English' checkbox in the File inspector/Localization:
...and that will create my string files for English localization (Notice the 'Japanese' checkbox below 'English'. I'd rather it not be there at all, because the Base xibs/storyboards already have Japanese text labels by default, but I can just leave it unchecked).
Now, the Project's Info pane, 'Localizations' section looks like this:
ADDENDUM: Now that I think of it, with things setup like this, if someone ever launches this app on (say) an iPhone set to French, the app will fall back to Japanese (not English). This is probably not ideal, since the default language for non-Japanese speakers should be English, not the other way around.
However, I can not afford to design my xibs with English text and translate them to Japanese afterwards.
I'm developing an internationalized version of my Cordova+Ionic app for iOS. The current app name is in Swedish, and I want to keep the name for the Swedish market, but the international app will have a new name.
I need the app to have the Swedish name for all users in Sweden, regardless of the chosen language. Is it possible to localize the app name based on region only?
I know you can localize it using a InfoPlist.strings resource with CFBundle(Display)Name properties, but the locales used to determine what resource to use are (as far as I'm aware) solely based on the devices preferred language/locale setting and takes no consideration about the device's region setting.
For instance, the resource for the en-GB locale (located at en-GB.lproj/InfoPlist.strings) is loaded when the preferred language is set to English (United Kingdom), but not for English with region set to United Kingdom.
Thanks
No, currently that is impossible
This is the extract from the documentation:
First, the bundle determines which localization to use for the application as a whole. If a .lproj folder exists for the preferred language, that localization is used. Otherwise, the bundle searches for an .lproj folder matching the next preferred language, and so on, until one is found. If there is no localization for a preferred language, the bundle chooses the development language localization.
I've looked through some internationalization documentation and videos on apple developer, but I never found an explicit answer to that question. In Apple's tutorials I see the Base.lproj folder alongside en.lproj and zh.lproj -- the example translation (localization) is from English to Chinese. But they tell me that there's a file en.lproj/myStoryboard.strings, and that is confusing. I can't see the point in creating an English localization for the storyboard (that is already in English).
So my questions are if the user will ever see the strings in the Base.lproj/myStoryboard.storyboard?
Do the strings in that file have to be the default strings that are shown to the user if the system cannot find the user's preferred language folder in my bundle?
Can I explicitly say "never use Base.lproj/myStoryboard.storyboard, always fall back on en.lproj/myStoryboard.strings"?
In other words:
Let's say I want my app to display in English whenever the user's language isn't available, but that my Base.lproj/myStoryboard.storyboard is in Swedish. Do I then have to localize the Base Storyboard to sv.lproj/myStoryboard.strings and translate all strings in the Base storyboard to English to accomplish this?
In my case, XCode 5 didn't create a en.lproj/myStoryboard.strings, there's only the original storyboard in the Base.lproj folder. Maybe it's an old XCode issue?
Try to remove that file and see if your app gets along with Base.lproj for default, English strings.
Your Info.plist file should have an entry Localization native development region, which points to the lproj folder to be used in case the required string doesn't exist in the preferred language.
I'm not sure about this, but I think you have to use en and UI with a Base.lproj would automatically fallback to Base.lproj.
Does that help you in any way?
So my questions are if the user will ever see the strings in the Base.lproj/myStoryboard.storyboard?
It is the default to use those strings for the development region localization, which is typically English. If there was a matching strings file for english, it would supersede the strings in the storyboard. This is typically redundant, so it isn't normally used. If you really want all of your languages to be handled identically, you can do this.
Do the strings in that file have to be the default strings that are shown to the user if the system cannot find the user's preferred language folder in my bundle?
These are unrelated concepts. The strings embedded in the storyboard are equivalent to having ones in en.lproj. After that, language fallback works the same as without Base.lproj.
Can I explicitly say "never use Base.lproj/myStoryboard.storyboard, always fall back on en.lproj/myStoryboard.strings"?
If you have en.lproj/myStoryboard.strings, and english is the development language, they will always superseded the strings embedded in Base.lproj/myStoryboard.storyboard for English. Including when English isn't the preferred language, but ends up being chosen as the fallback language.