In my iOS app, I am planning to let user to change the language.
What is the best approach to accomplish this?
Currently all my String is inside a struct. But I am wondering what is the best approach to change language according to what user choose.
Any suggestions?
The most common way to do this is not to allow the user to change the language within the app itself, but rather let iOS do this for you.
Here's a good tutorial to start localizing your app's strings using NSLocalizedString. You should follow the whole tutorial as it has a bunch of useful information about localization, but here's a brief overview of what you have to do:
Create a Localizable.strings file for your project. This file follows the format "Hello" = "Hello";, where the key on the left will be the string's identifier for NSLocalizableString and the value on the right is the localized string. In this case, you would replace any code references to this string (for example, #"Hello") with NSLocalizedString(#"Hello", nil).
Add your desired languages to your app's project (Project > [App name] > Localizations > "+" button). This will present a prompt containing your project's localizable files (strings files and storyboards) - you'll probably want to select all of them.
Select your Localizable.strings file, and in the Utilities (right side) menu, under Localization, click Localize. Select English as your starting language (assuming your app is currently in English).
You'll now have a list of your localizable languages with checkboxes. Enable each language, which will create a language-specific version of Localizable.strings.
All of your localized files, including Localizable.strings and your Storyboards, will now have a arrow in the Project Navigator. If you click these arrows to expand, you can edit each of your localizations for these files.
Done! Easy. You can test this in the Simulator or on your device by changing your device's language.
Once this has been completed, your app will load strings from whichever supported language the user has selected in their device settings.
This question also has some useful tips for localizing an existing app - in particular, mass-replacing existing strings with NSLocalizedString.
If you want to do your own solution then one of the many possible ways would be to:
Create your own singleton Localization Manager Class
Add every UILabel in the App into a dictionary which holds an UILabel and the key string. Then just:
for label in labels {
If let label = LocMan.sharedInst.labels["some Key"] {
label.text = NSLocalizedString("some Key" comment: "")
}
}
For other text classes you should do the same.
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.
Does Xcode or Swift have a list of predefined localized words (e.g. "Delete", "Edit" etc.) that I can use in my app and to be sure that it localized properly?
If you have a Navigationview and you use a Navigationlink, you will see, that the back button will be localized automatically (at lest for german in my app). So all buttons that get generated for you, could be localized for some languages.
But as far as I know, there is no set of predefined localizations you could access to use. Though it is very easy in SwiftUI to make localizations, just have a look at:
https://phrase.com/blog/posts/swiftui-tutorial-localization/
If you have a string file with your localizations you can use the definitions of those strings directly in the text parameters of the SwiftUI Views and they will automatically be changed with the localized version, no need to even cast the identifier of the string in the strings file to a LocalizedStringKey.
Seriously, if you were to rely on some automatic translation for your UI, then I can promise you that people will complain, because most will find an automatic translation into their own language harder to read than good English.
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 learning from the iOS 9 AppCoda book on Swift (https://www.appcoda.com/swift/) and I am stuck in particular on the Localization section. So the author has gone through with changing some user-facing strings in code from just String to NSLocalizedString. That makes sense and the changes I made there were automatically updated appropriately with the XLIFF file. In the section about Localisation, the author mentions that you can also translate Storyboard user-facing Strings with the Export Localization feature of Xcode.
Because it's a book you work through, he provides an already translated XLIFF file into Chinese and German which includes the source code translated text and the Storyboard elements translated as well.
When I import the files into Xcode, I see three storyboards (Base and the Chinese/German.strings, etc) but when I run the app, none of the Storyboard elements are actually translated and only the elements from the source code.
When I click on the German Storyboard, I get the "no localized strings".
The app in his example works and the UI elements in storyboard are translated but they're not in my case. The entire app thus far has been followed with the exercises so there aren't really any differences. Or even if there are, the similarities themselves should be translated, but in the Storyboard elements, they're not.
Does anyone have any ideas on why the Storyboard elements wouldn't be updated with the Translated text in my case?
Any thoughts would be appreciated.
Here is my guess... Exporting localization strings from Storyboards works a little different from exporting those strings from code.
The localization file for strings from code gets the actual text from the NSLocalizedString macro and creates a mapping such as:
"Original string" = "Translated string".
So, you just have to use "Original string" in your code then Xcode knows it should translate it to "Translated string".
However, the storyboard localisation file uses the UI objects handles to set localized strings. For example:
/* Class = "UILabel"; text = "Ops..."; ObjectID = "fe4-zT-gjU"; */
"fe4-zT-gjU.text" = "Wait for it...";
In this example my storyboard has a UILabel, with the text "Ops...", and that label has an ObjectID equal to "fe4-zT-gjU".
The object IDs are kinda unique for each object in each project, so obviously the object IDs from the app coda tutorial will be unique for the project the author created; unless you have downloaded the author's original storyboard, your storyboard will have all different object IDs, so Xcode won't know how to associate the correct translations to the correct objects.
I don't think Xcode will import localisation for objects with objectIDs it doesn't recognise.
So what I think you should do is to perform an "Export for localisation" operation. This should update your storyboard .strings file. Then you copy each translation from the tutorial file into your .strings file using an xliff editor. Boring, I know. Welcome to the app development world. :-)
When you added your localization did you select the storyboard file?
If so, then check that your scheme is set to the correct language. This can be done under Product > Scheme > Edit Scheme
If that doesn't do it, then check that your simulator is set to the language you want to display. This can be done in the simulator's settings, same as an iPhone.
Hope this helps.
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.