Patent Grant
12147779
The present invention generally relates to operations within communication networks and, more particularly, to mechanisms and techniques for providing support for multiple languages for applications which operate with business support systems (BSS).
Over time the number of products and services provided to users of telecommunication products has grown significantly. For example, in the early years of wireless communication, devices could be used for conversations and later also had the ability to send and receive text messages. Over time, technology advanced and wireless phones of varying capabilities were introduced which had access to various services provided by network operators, e.g., data services, such as streaming video or music service. More recently there are numerous devices, e.g., so called “smart” phones and tablets, which can access communication networks in which the operators of the networks, and other parties, provide many different types of services, applications, etc.
Using these various services and applications (which for simplicity will both be called “applications” herein) can involve various forms of communication. For communication with human beings, text plays a very important role, even though most of the communication is supported by pictures, icons and other media. Communication using only pictures is typically not sufficient. Any type of presented media often provides texts in the language which can be understood by the target audience. Digital frontends often provide a mechanism to translate the control elements on the screen, e.g., menu items which are static, but most of the time these digital frontends lack the ability to translate and/or provide alternative texts for data content which can dynamically change over time. The phrase “alternative texts” describes both a typical language translation into one or more languages as well as the outputted text associated with using an artificial language. For example, using an artificial language of en-kids (children's English) the salutation of “Dear Sir” or “Dear Madame” could result in the alternative text of “hello friend”. The same problem also applies to printed content. Additionally, even though the text template is available in different languages, the dynamically rendered content is not.
As there are many different types of applications provided via communication networks to end users that use a plurality of different languages, the current networked society in a global world could benefit from better multi-language support. Many frontend applications have some form of support for using, storing and delivering information and/or data. However, these applications lack support for showing the information and/or data in multiple languages.
Multiple language support can be divided into two areas, e.g., support of multiple language user interfaces (UIs) and support for translating data entities. Support of multiple language UIs is conventionally done by currently known technologies, e.g., resource bundles. Resource bundles are a Java™ mechanism used to isolate specific data which target UIs and messages for a single application. Resource bundles are a static design time approach which must be deployed to the application instances. These resource bundles can be extended only at the design time and thus, resource bundles are not a viable solution for translating data entities.
Support for translating data entities and alternative texts into multiple languages needs to be foreseen in the application at the time of its conception or design and requires a different approach as compared to resource bundles and UI translation. Today, applications typically use a variety of proprietary solutions for managing alternative texts in multiple languages, with these solutions being more or less static and requiring additional deployment to the application instances. Examples of these solutions include storing texts in separate database tables and linking them to the entities which own them, storing texts in files which are loaded or converted into resource bundles to be deployed to the application instance and storing texts in files which are then cached and refreshed when new texts are added.
All of the known, existing solutions target the translations of texts belonging to a single application. Currently there is no central repository to provide alternative texts in multiple languages for entities used in a system, be it any type of entity, e.g., data, screen or system, that carries information that is to be consumed by an audience, apparatus and/or other consumer of information. Further, there is no centralized solution available which allows supporting and externalizing translations which are performed across multiple applications. In addition, adding new translations for legacy systems outside of an organization's control is very difficult without expending a significant coding effort in order to take care of storing and managing new texts in one or more alternative languages, adapting the translation process to account for the new translations, and to add the needed retrieval and display logic. Indeed in many cases adding new translations and alternative texts to various data entities associated with an application can require a full data migration effort.
Thus, there is a need to provide methods and systems that overcome the above-described drawbacks associated with respect to multiple language translations of text associated with applications and the like.
Embodiments described herein provides systems and methods which allow adding centralized support for texts in multiple languages to applications without the need for a full data migration. Various mechanisms provide a common approach to configure “plain” translation for texts in different languages and dialects as well as alternative texts for different contexts, e.g., channels and specific target audiences. Additionally, using a common and centralized mechanism can add multi-language support for content which does not currently have this support.
According to an embodiment, there is a method for translating text in a first language into text in a second language, the method including: receiving a first message in the first language; parsing text from the first message into one or more portions, wherein each portion is identified by a unique identifier; translating each portion into a second language, wherein each translated portion is identified by the unique identifier; combining each translated portion into a logical format for use by a user; and returning the logical format in a second message in the second language for consumption by the user.
According to an embodiment, there is a communication node for a translating text in a first language into text in a second language, the communication node including: communication interface configured to receive a first message in the first language; a processor configured to parse text from the first message into one or more portions, wherein each portion is identified by a unique identifier; the processor being further configured to translate each portion into a second language, wherein each translated portion is identified by the unique identifier; the processor being further configured to combine each translated portion into a logical format for use by a user; and the communication interface being further configured to return the logical format in a second message in the second language for consumption by the user.
According to an embodiment, there is a computer-readable storage medium containing a computer-readable code that when read by a processor causes the processor to perform a method for translating text in a first language into text in a second language, the method including: receiving a first message in the first language; parsing text from the first message into one or more portions, wherein each portion is identified by a unique identifier; translating each portion into a second language, wherein each translated portion is identified by the unique identifier; combining each translated portion into a logical format for use by a user; and returning the logical format in a second message in the second language for consumption by the user.
According to an embodiment, there is an apparatus adapted to receive a first message in the first language, parsing text from the first message into one or more portions, wherein each portion is identified by a unique identifier; translating each portion into a second language, wherein each translated portion is identified by the unique identifier; combining each translated portion into a logical format for use by a user; and returning the logical format in a second message in the second language for consumption by the user.
According to an embodiment, there is an apparatus including: a first module configured to receive a first message in the first language, a second module configured to parse text from the first message into one or more portions, wherein each portion is identified by a unique identifier; a third module configured to translate each portion into a second language, wherein each translated portion is identified by the unique identifier; a fourth module configured to combine each translated portion into a logical format for use by a user; and a fifth module configured to return the logical format in a second message in the second language for consumption by the user.
The accompanying drawings, which are incorporated in and constitute a part of the specification, illustrate one or more embodiments and, together with the description, explain these embodiments. In the drawings:
The following description of the embodiments refers to the accompanying drawings. The same reference numbers in different drawings identify the same or similar elements. The following detailed description does not limit the invention. Instead, the scope of the invention is defined by the appended claims. The embodiments to be discussed next are not limited to the configurations described below, but may be extended to other arrangements as discussed later.
Reference throughout the specification to “one embodiment” or “an embodiment” means that a particular feature, structure or characteristic described in connection with an embodiment is included in at least one embodiment of the present invention. Thus, the appearance of the phrases “in one embodiment” or “in an embodiment” in various places throughout the specification is not necessarily all referring to the same embodiment. Further, the particular features, structures or characteristics may be combined in any suitable manner in one or more embodiments.
As described in the Background section, there are problems associated with current methods for performing multiple language translations of text associated with applications and other products/services which interact with users and devices. “Applications”, as described herein, include applications, services and other products, typically obtainable through a communication or operator network, for which multiple language translations could be useful.
Embodiments described herein provide systems and methods which enable centralized support for texts in multiple languages to applications without the need to perform a full data migration. These systems and methods address alternative texts to be captured for data entities managed by the applications with a focus on configuration and efficient retrieval of the alternative texts at runtime. Alternative texts can be configured for different languages, e.g., English, German, Swedish and Chinese, different dialects of these languages, artificial languages, as well as different contexts, e.g., frontend channels and/or the intended audience. Examples of artificial languages include, but are not limited to, en-Kids (kids English and salutations), en-Teens (teenager's English), de-Kinder (children's German) and ru-ASCII7 (for displaying Russian strings on certain phones which do not display Cyrillic characters). Other embodiments enable serving both applications which have foreseen a need for alternative texts and/or translations as well as applications which do not express a potential need (even if one day the applications may have this need) for managing translations or alternative texts in other languages. One example of an application according to these embodiments which illustrates centrally managing translation or alternative texts in other languages is an application in which strings of text to be translated are decoupled from the object.
Prior to describing these and other embodiments in more detail, an overview of a process for performing the translations of the alternative texts is described. According to an embodiment, a text entity can be created as an entity skeleton which is aligned to the structure of a base entity for which the text entity carries the texts. The entity skeleton can be created as a hierarchical structure which identifies each structural node by entity type and entity identification (ID). Further, each structural node can include information describing the language or dialect in which the string was entered, translatable properties and a translated value. Each translatable property can be identified by a concatenation of node keys and property name as well as an optional unique string reference ID.
According to an embodiment, a serialization mechanism for translations and alternative texts belonging to the same object hierarchy is provided. This serialization mechanism creates a representation of the entity skeleton populated with texts for translatable properties. The serialization result is a blob, which is a flattened string, which can cope with any base object hierarchy. An example using pseudo code associated with a Location is shown below for illustration.
The text entries include a language, a normalized root entity key and the serialization result.
Embodiments can interact with both structured query language (SQL) and non-SQL databases. For example, given an SQL database, the serialization mechanism can be executed prior to persisting the translation and given a non-SQL database, the serialization mechanism can be a part of the conversion to the blob which is representing the translations. The operation of creating translations can be supported by direct write operations to the text entities or, for example, by a file-based import/export mechanism using a common file format. Additionally, at runtime, the translated texts can be addressed and retrieved by using the concatenated key, navigating the entity hierarchy or by a unique string reference ID.
The foregoing provides a general overview of translation systems according to embodiments described herein. The following text describes the embodiments in greater detail and can be considered as having four parts: (1) a first section associated with describing the different data structures and entities illustrated in
Starting then with the data entities used in embodiments,
According to an embodiment, alternative texts can be stored in a compressed blob-format combining structured addressing with an ID-based addressing mechanism. An example of a logical structure 400 for managing alternative texts can be depicted as shown in
This logical structure can support any type of composite entity structures. Reusing StringReferenceID 416 is possible. For example, StringReferenceID 416 can be used as a signal to the translation solution that the translated values should be shared. The EntityIdentification 402 needs to be unique with respect to context only, in other words, the root entityIdentifier 410 needs to be unique within the entityType 408 and the identifiers of entities on composite levels have to be unique with respect to the context of the entity type and the owning entity. In other words, when one refers to the node of a hierarchical structure, then the ID of the next subnode needs to be unique in the context of its parent node.
StringReferenceIDs 416 (also referred to herein as reference ID strings) are a type of data string and should be unique among all client applications that use the centralized translation service. Uniqueness can be achieved by, for example, using universally unique identifiers (UUIDs). If name based UUIDs are used, these will typically not be just random, but also re-creatable. Alternatively, according to another embodiment, reference ID strings can be constructed as a concatenation of a name space defined by the client application combined with some form of application proprietary logic for uniqueness, e.g., using a database sequence.
According to another embodiment, in some scenarios for performance optimization or to avoid concurrency, the logical structure of
According to another embodiment, while the persistence solution can be optimized for reading by root-type and root-id, a back-reference can also be implemented to provide a lookup from StringReferenceID 602 as shown in logical structure 600. It is to be understood that the logical structures 400, 500 and 600 can be further modified and combined as desired in supporting the various embodiments associated with multi-language translations as described herein.
According to an embodiment, there is a mechanism that uses the entities and logical structures described above with respect to
Entries in other languages can be added by import/export mechanisms or by dedicated UIs. These UIs or file-based translation procedures can be centralized as well, since they operate on a centralized repository of text objects across all applications using the alternative text services. Entries for alternative text anchors can be created by batch when applying the add-on functionality for alternative texts.
According to an embodiment, a serialization algorithm is applied to create a translation entry for a hierarchical structure. This translation entry includes a key and a binary data blob. The key is made from the triplet of Root Entity Type, which is a string, rootEntityID, which is a unique string within the same root entity type, and the language. The root entity type can be any kind of string identifying the data object, e.g., address, product, etc. As used herein, the root entity is a base entity on the top level of the hierarchy and base entities, in general, are objects where the initial skeleton is built from. The rootEntityID is an ID which is unique per entity-type. The language is a language identifier compliant to a locale or the base language of a locale. The triplet of Root Entity Type, rootEntityID and language, is a key which is unique in the scope of the alternative text solution. The data blob is a serialization of a hierarchical structure made up of entity keys (type and ID) as well as arrays of translatable string property, string value and string reference triplets. A back-reference object is created for each translation entry, which supports a second access path via the string reference ID.
Having described the general data structures and entities which can be used by the embodiments, the discussion now turns to various processes which use these data entities and structures to perform translations. According to an embodiment, a flowchart 700 illustrating serialization of an object hierarchy is now described with respect to
According to an embodiment, a flowchart 800 illustrating serialization of translatable string properties of an object is now described with respect to
In step 816, it is determined if a lookup entry for the String RefID exists for the current property. if the answer is no, a lookup entry is created for the current property in step 818. Once it is determined if there is a lookup entry or if a lookup entry is created for the current property, the process returns to step 804 to determine if there is another translatable string property for the current process. If yes, the above described flow as shown in
Using the serialization “engine” from the text services and creating a string containing a json structure of all nodes & there string properties below a root entity is shown below using the serialization as described in
According to an embodiment, the ability to create entries for alternative texts by addressing them via structured keys can be the prerequisite for an adjunct solution. The ability to manage string references in parallel as a second addressing mechanism allows to combine solutions, which support decoupling of translatable strings from the entities they manage, with other applications which do not currently have support for translatable strings in the system.
According to an embodiment, access to the alternative texts in the request language can be provided by accessing all of the strings of an object or list of objects for a target language by structured addressing and/or by accessing a list of strings for a target language by absolute addressing. An application which wants to provide alternative texts for its own data objects can request the alternative texts for a list of target languages using the APIs provided by the multi-language component.
Text can be accessed by using the structured key. For example, for retrieving an alternative string for an entity property in a requested language, the serialized translation blob is retrieved by using the structured key consisting of root entity type, root entity ID and language. The alternative texts contained in the translation blob are then either returned as a whole or only for a dedicated sub-entity respectively for a single string. Embodiments can also allow for optimizing performance when all alternative texts belonging to an entity or sub-entity are returned together, since this allows for efficient merging on the client side.
According to an embodiment, a process for obtaining translated strings using a structured key is now described with respect to the flowchart 900 shown in
However, if the determination is made at step 908 to not return the whole object to the client, the process moves along to step 910 which navigates to a string associated with the structured key. In step 912 the translated string is returned to the client followed by ending the process as shown in step 916.
According to an embodiment, there also is a mechanism to access text by using the StringReference ID as shown in flowchart 1000 with respect to
According to an embodiment, access to alternative texts can be extended to support a fallback mechanism. Additionally, in case a translation entry for a requested language is missing, the alternative text services will implement a fallback logic to check for the availability of an alternative text in the base language.
According to an embodiment, an example of a flowchart 1100 illustrating fallback logic to check for the availability of an alternative text is now described with respect to
If the outcome of any of the determination steps 1104, 1108 or 1110 is a yes, then the process proceeds to step 1114 in which a determination is made as to whether or not to return the whole object to the client. At this point, beginning with step 1114, steps 1116, 1118, 1120, 1122 and 1124 replicate the steps 904, 906, 908, 910, 912 and 914, respectively, as shown in
According to an embodiment, the mechanism to access a string by its Reference ID can support an extended log with default handling as illustrated by the flowchart 1200 shown in
As described above and shown in the various Figures, there exist methods and systems for generating translations for alternative texts. The following description associated with
Prior to describing
The entity Location includes ID, name, description, a list of cell IDs and a sub-entity (or child entity) characteristic for a region with name. For this example, it is assumed that the system is using so-called “plain” English, thus the system language is en-UK. The “base entity” Location for the particular location “Karlskrona” appears as shown below with respect to Table 1.
The associated child entity for the region characteristic is shown below in Table 2.
When a product catalog application is used to create the Location entity, the product catalog application will call the centrally located translation services to instantiate a skeleton entity for en-UK, which contains the strings to be translated. The translation services will also create an entity for the back-reference. The structured key for the skeleton entity is: Location/544321/en-UK. The properties of the skeleton entity are serialized to a string which includes the following information as shown in Table 3.
Using the above provided information, an example of the base entity and its associated linked skeleton entity for the Location entity can be seen in
Continuing with this example, a back-reference object used for the lookup based on the string ID is created having the following content as shown in Table 4.
As described above, the back-reference lookup is used for generating unique IDs for each string ID for future reference.
After generating the back-reference lookup in this example, translation using the skeleton entity 1304 can occur. Using either a translation UI or a file-based import/export mechanism, translation entities for various languages and dialects can be created. For this example, translation services are used to read the skeleton entity 1304, which is in en-UK, which is used as a template and context information for the translation entities to be created. A translation entity for Swedish (se) and German (de) are used. A key of the translation entity in Swedish is Location/544321/se and the key of the translation entity in German is Location/544321/de. The properties of both of the skeleton entities are serialized to their respective string which carries the translated string as shown below, with Table 5 being for Swedish and Table 6 being for German.
Putting Tables 5 and 6 into the hierarchical form,
According to an embodiment, translation services offer different access mechanisms for texts in alternative languages. All texts of an entity can be accessed by coarse grained operations. Additionally, texts for single string attributes can be addressed individually. When accessing all texts of an entity the entity key which includes entity type and ID is specified together with the intended language. If an entity translation is available in the requested language/dialect/lingo the translation entity can be returned. If no translation is available in the requested language, the fallback mechanism can be applied which attempts to find the closest match. Thus, if for example, the language/dialect combination de-CH (Swiss standard German) is requested, in the current example, the translation entry for de is returned. If the language/dialect ru (Russian) is requested, then as there is no close match available, the translation entity of the default language, which is the skeleton, will be returned.
As described above, according to an embodiment, it is possible to access a specific string property by using the unique stringID with the language/dialect/lingo. If, for example, the Swedish text for stringID=12366 is requested, the text services will access the back-reference lookup table and retrieve the hierarchical reference of the string attribute, which for the current example is Location/544321/Description. From the hierarchical reference, the key of the translation entity is extracted by using entity type and ID and appending the target language. This then results in the following structured key: Location/544321/se. The structured key to the translation entity is used to read the serialized string representation, perform a deserialization and to access the translated value of the property labelled “Description”. For performance optimization, a translation entity, which has been de-serialized once, is kept in memory and used from there for subsequent requests. In case of updates on the translation, the memory is invalidated and refreshed on the next access.
According to an embodiment there is a method for translating text in a first language into text in a second language as shown in
Network 1820 may comprise one or more IP networks, public switched telephone networks (PSTNs), packet data networks, optical networks, wide area networks (WANs), local area networks (LANs), wireless local area networks (WLANs), wired networks, wireless networks, metropolitan area networks, and other networks to enable communication between devices. Additionally, an OCS 302 and core network (CN) 306 are shown.
Network node 1800 comprises processor 1802, storage 1803, interface 1801, and antenna 1801a. These components are depicted as single boxes located within a single larger box. In practice however, a network node may comprise multiple different physical components that make up a single illustrated component (e.g., interface 1801 may comprise terminals for coupling wires for a wired connection and a radio transceiver for a wireless connection). As another example, network node 1800 may be a virtual network node in which multiple different physically separate components interact to provide the functionality of network node 1800 (e.g., processor 1802 may comprise three separate processors located in three separate enclosures, where each processor is responsible for a different function for a particular instance of network node 1800). Similarly, network node 1800 may be composed of multiple physically separate components (e.g., a NodeB component or gNB component and a RNC component, a BTS component and a BSC component, etc.), which may each have their own respective processor, storage, and interface components. In certain scenarios in which network node 1800 comprises multiple separate components (e.g., BTS and BSC components), one or more of the separate components may be shared among several network nodes. For example, a single RNC may control multiple NodeB's. In such a scenario, each unique NodeB and BSC pair, may be a separate network node. In some embodiments, network node 1800 may be configured to support multiple radio access technologies (RATs). In such embodiments, some components may be duplicated (e.g., separate storage 1803 for the different RATs) and some components may be reused (e.g., the same antenna 1801 may be shared by the RATs).
Processor 1802 may be a combination of one or more of a microprocessor, controller, microcontroller, central processing unit, digital signal processor, application specific integrated circuit, field programmable gate array, or any other suitable computing device, resource, or combination of hardware, software and/or encoded logic operable to provide, either alone or in conjunction with other network node 1800 components, such as storage 1803, network node 1800 functionality. For example, processor 1802 may execute instructions stored in storage 1803.
Storage 1803 may comprise any form of volatile or non-volatile computer readable memory including, without limitation, persistent storage, solid state memory, remotely mounted memory, magnetic media, optical media, random access memory (RAM), read-only memory (ROM), removable media, or any other suitable local or remote memory component. Storage 1803 may store any suitable instructions, data or information, including software and encoded logic, utilized by network node 1800. Storage 1803 may be used to store any calculations made by processor 1802 and/or any data received via interface 1801.
Network node 1800 also comprises interface 1801 which may be used in the wired or wireless communication of signaling and/or data between network node 1800, network 1820, and/or WD 1810. For example, interface 1801 may perform any formatting, coding, or translating that may be needed to allow network node 1800 to send and receive data from network 1820 over a wired connection. Interface 1801 may also include a radio transmitter and/or receiver that may be coupled to or a part of antenna 1801a. The radio may receive digital data that is to be sent out to other network nodes or WDs via a wireless connection. The radio may convert the digital data into a radio signal having the appropriate channel and bandwidth parameters. The radio signal may then be transmitted via antenna 1801a to the appropriate recipient (e.g., WD 1810).
Antenna 1801a may be any type of antenna capable of transmitting and receiving data and/or signals wirelessly. In some embodiments, antenna 1801a may comprise one or more omni-directional, sector or panel antennas operable to transmit/receive radio signals between, for example, 2 GHz and 66 GHz. An omni-directional antenna may be used to transmit/receive radio signals in any direction, a sector antenna may be used to transmit/receive radio signals from devices within a particular area, and a panel antenna may be a line of sight antenna used to transmit/receive radio signals in a relatively straight line.
WD 1810 may be any type of wireless endpoint, mobile station, mobile phone, wireless local loop phone, smartphone, user equipment, desktop computer, PDA, cell phone, tablet, laptop, VoIP phone or handset, which is able to wirelessly send and receive data and/or signals to and from a network node, such as network node 1800 and/or other WDs via uplink signals or sidelink signals, respectively. WD 1810 comprises processor 1812, storage 1813, interface 1811, and antenna 1811a. Like network node 1800, the components of WD 1810 are depicted as single boxes located within a single larger box, however in practice a wireless device may comprises multiple different physical components that make up a single illustrated component (e.g., storage 1813 may comprise multiple discrete microchips, each microchip representing a portion of the total storage capacity).
Processor 1812 may be a combination of one or more of a microprocessor, controller, microcontroller, central processing unit, digital signal processor, application specific integrated circuit, field programmable gate array, or any other suitable computing device, resource, or combination of hardware, software and/or encoded logic operable to provide, either alone or in combination with other WD 1810 components, such as storage 1813, WD 1810 functionality. Such functionality may include providing various wireless features discussed herein, including any of the features or benefits disclosed herein.
Storage 1813 may be any form of volatile or non-volatile memory including, without limitation, persistent storage, solid state memory, remotely mounted memory, magnetic media, optical media, random access memory (RAM), read-only memory (ROM), removable media, or any other suitable local or remote memory component. Storage 1813 may store any suitable data, instructions, or information, including software and encoded logic, utilized by WD 1810. Storage 1813 may be used to store any calculations made by processor 1812 and/or any data received via interface 1811.
Interface 1811 may be used in the wireless communication of signalling and/or data between WD 1810 and network node 1800. For example, interface 1811 may perform any formatting, coding, or translating that may be needed to allow WD 1810 to send and receive data from network node 1800 over a wireless connection. Interface 1811 may also include a radio transmitter and/or receiver that may be coupled to or a part of antenna 1811a. The radio may receive digital data that is to be sent out to network node 1801 via a wireless connection. The radio may convert the digital data into a radio signal having the appropriate channel and bandwidth parameters. The radio signal may then be transmitted via antenna 1811a to network node 1800.
Antenna 1811a may be any type of antenna capable of transmitting and receiving data and/or signals wirelessly. In some embodiments, antenna 1811a may comprise one or more omni-directional, sector or panel antennas operable to transmit/receive radio signals between 2 GHz and 66 GHz. For simplicity, antenna 1811a may be considered a part of interface 1811 to the extent that a wireless signal is being used.
The non-limiting term UE refers to any type of wireless device communicating with a network node in a cellular or mobile communication system over radio interface. Examples of UEs are target devices, device to device (D2D) UEs, proximity-based service (ProSe) UEs, machine type UEs or UEs capable of machine to machine communication (aka category 0 UEs, low cost and/or low complexity UEs), PDAs, iPADs, tablets, mobile terminals, smart phones, laptop embedded equipment (LEE), laptop mounted equipment (LME), USB dongles, wireless devices etc. An example of a UE 1810 is illustrated in
Various embodiments described herein refer in some fashion to nodes, e.g., the communication node which performs the centralized translation function 1820 which as described above can be associated with Charging and/or other BSS functions. In some embodiments the non-limiting network node (also interchangeably called as node) is more commonly used and it refers to any type of network node which directly or indirectly communicates with the UE. It can be a radio network node or a node in a core network or fixed part of the network such as the node 1820. For example, it can be a network node serving the UE, a network node neighboring to the serving network node of the UE, any network node in the radio network or in the core network in wireless communication system in which UE operates. Examples of network nodes are base stations (BS), multi-standard radio (MSR) radio nodes such as MSR BS, eNode B (eNB), network controllers, radio network controllers, base station controllers, relay, donor node controlling relays, base transceiver stations (BTS), access points (AP), core network nodes (e.g. MSC, MME etc), O&M, OSS, SON, location server (e.g. E-SMLC), MDT etc. It is to be understood that network node 1820 includes functional pieces similar to those shown for base station 1800.
The embodiments described herein can be used in customer relationship management (CRM) applications or other frontend applications such as applications which have to present data with alternative texts in multiple languages. Embodiments describe various mechanisms which provide a common approach to configure “plain” translation for texts in different languages and dialects as well as alternative texts for different contexts, e.g., channels and specific target audiences. Embodiments using a common and centralized mechanism can add multi-language support for content which do not currently have this support. Additionally, embodiments can provide multiple language support in a diversified environment in the cloud combining applications which foresee desiring multiple language support with applications which do not for see this need. Also, embodiments provide for optimized storage and access for alternative texts on data entities.
As described above, embodiments provide the ability to capture and retrieve alternative texts in multiple languages for string properties of any type of object, be it business objects, e.g., entities of a product catalog, or system objects, e.g., error messages, or frontend user interface (UI) objects. Embodiments combine two different techniques of addressing strings which are externalized from the owning entities for translation. The two different techniques are as follows: (1) using a structured addressing exposing all strings belonging to an object; and (2) using a unique identifier for the string.
The embodiments described herein are agnostic with respect to specific object or data structures and provide a general way of externalizing strings in multiple languages or locales into an entity structure which is optimized for read performance and thus compatible for storage in a non-SQL database. Additionally, embodiments are generic in the sense that string properties for any type of objects having different potentially hierarchical structures are referenced by a logical addressing describing the structural nodes, and thus can be managed in a central place without losing context from where the translation originates.
According to an embodiment, alternative texts can be configured for logical languages. As used herein, a logical language is a string, which is built according to one of the following options: the Java™ locale, the two digit base language code from the Java locale; or a flexible non-standardized combination of a two digit language abbreviation and an additional string to indicate the dialect, country or lingo according to the following regular expression: ([a-z][a-z]\-(\w){1,255})[a-z][a-z]. The regular expression allows either a 2-digit language abbreviation ([a-z][a-z]) or the language abbreviation extended with a dialect string separated by “-” ([a-z][a-z]\-(\w){1,255}). Using regular expressions is one possible way to ensure using the correct language format in case the language is specified with a dialect. The format check on the language string is used to be able to easily define language groups which allow for a fallback strategy in case a certain translation or alternative text does not exist. It is too be understood that the above shown regular expression is only a non-limiting example and that other algorithms can be used.
Some examples of a language configuration are as follows: en (English default), en-US (English US dialect), en-UK (English UK dialect), en-APP1 (a special dialect for APP1, e.g., only ASCII7 characters as only those are supported in APP1), en-SMS (special sorts texts and abbreviations in English and, en-KIDS (kids language and salutations in English). Each of these languages are intended for a certain audience. In the simplest scenario, where a human who is able to interpret and understand English, the language configuration “en” would be used. It can even be so, that the language configuration is even more specific, by defining a certain type of dialect, in this case en-US can be used where en is referring to the English language and US the American country. If the intended audience is kids that speak English, language configuration would be en-KIDS. It might even be so that the intended audience is using a cellphone to receive a message, were the maximum length of the text message is 160 characters, the language configuration en-SMS could be used
As long as there is an understanding of the format of the “language” to all client applications using the alternative text services, context sensitive texts for objects can be supported. The language can also be used to translate into technical languages for human to machine or machine to machine communications when, for example, the language can be turned into something logical and/or executable than just a text that has the goal of being interpreted by a human being. Thus, according to an embodiment, the alternative text mechanism can even be used as a converter between two applications which do not communicate in the same language.
According to an embodiment, an overall system language can be configured which can be used to support a fallback mechanism in case of missing translations. The system language can also be used for translation workflows to serve as a source string which is then provided in other target languages to be supported. The alternative text services can support an optional fallback mechanism between translations. This default handling ensures that a reasonable text is returned if a certain text is missing for a certain language.
According to an embodiment, there can be a fallback mechanism. For example, if an alternative text entry for a root entity does not exist, the system can search for an entry in the base language instead. If this entry in the base language is also not found, then the system can search for an entry in the system language, provided the system language is configured.
According to an embodiment, the alternative text service manages all languages in the same manner. There are typically no differences made between entries for a potential system language, entries for a base language or entries for a fully qualified logical language string. All entries have the same structure and contain the alternative texts in the respective language for the string properties in question. This allows for any of the languages to potentially be used in the role of the system language and for that instance no further migration is needed. The system language can be configured or switched at any point in time due to the peer structure of entries for all languages
It should be understood that this description is not intended to limit the invention. On the contrary, the embodiments are intended to cover alternatives, modifications and equivalents, which are included in the spirit and scope of the invention. Further, in the detailed description of the embodiments, numerous specific details are set forth in order to provide a comprehensive understanding of the claimed invention. However, one skilled in the art would understand that various embodiments may be practiced without such specific details.
As also will be appreciated by one skilled in the art, the embodiments may take the form of an entirely hardware embodiment or an embodiment combining hardware and software aspects. Further, the embodiments, e.g., the associated with translation into alternative texts, to include embodiments described herein, such as, the method associated with
Although the features and elements of the present embodiments are described in the embodiments in particular combinations, each feature or element can be used alone without the other features and elements of the embodiments or in various combinations with or without other features and elements disclosed herein. The methods or flowcharts provided in the present application may be implemented in a computer program, software or firmware tangibly embodied in a computer-readable storage medium for execution by a specifically programmed computer or processor.
| Filing Document | Filing Date | Country | Kind |
|---|---|---|---|
| PCT/EP2018/061587 | 5/4/2018 | WO |
| Publishing Document | Publishing Date | Country | Kind |
|---|---|---|---|
| WO2019/210977 | 11/7/2019 | WO | A |
| Number | Name | Date | Kind |
|---|---|---|---|
| 6826593 | Acharya | Nov 2004 | B1 |
| 8312110 | Muraki | Nov 2012 | B2 |
| 10740069 | Patino-Bueno | Aug 2020 | B2 |
| 20020156688 | Horn | Oct 2002 | A1 |
| 20020174150 | Dang | Nov 2002 | A1 |
| 20030110469 | Jackson | Jun 2003 | A1 |
| 20040230416 | Ye | Nov 2004 | A1 |
| 20040267803 | Zhou | Dec 2004 | A1 |
| 20060156278 | Reager | Jul 2006 | A1 |
| 20070233456 | Kim | Oct 2007 | A1 |
| 20070294077 | Narayanan et al. | Dec 2007 | A1 |
| 20080189096 | Apte | Aug 2008 | A1 |
| 20110137636 | Srihari | Jun 2011 | A1 |
| 20130067307 | Tian et al. | Mar 2013 | A1 |
| 20130326347 | Albright | Dec 2013 | A1 |
| 20140058719 | Travieso | Feb 2014 | A1 |
| 20150039287 | Han | Feb 2015 | A1 |
| 20150039295 | Soschen | Feb 2015 | A1 |
| 20150134322 | Cuthbert | May 2015 | A1 |
| 20150278190 | Ohara | Oct 2015 | A1 |
| 20160162478 | Blassin | Jun 2016 | A1 |
| 20160179481 | Ohara | Jun 2016 | A1 |
| 20160350108 | Joo | Dec 2016 | A1 |
| 20170344582 | Jurca | Nov 2017 | A1 |
| 20180032491 | Heo | Feb 2018 | A1 |
| 20180068225 | Miyoshi | Mar 2018 | A1 |
| 20180143975 | Casal | May 2018 | A1 |
| 20180322177 | Bhargava | Nov 2018 | A1 |
| 20190065479 | Wu | Feb 2019 | A1 |
| 20190311038 | Tu | Oct 2019 | A1 |
| 20210124790 | Travieso | Apr 2021 | A1 |
| 20230161975 | Mueller | May 2023 | A1 |
| Number | Date | Country |
|---|---|---|
| 1847923 | Oct 2007 | EP |
| Entry |
|---|
| International Search Report/Written Opinion dated Jan. 25, 2019 in related/corresponding PCT Application No. PCT/EP2018/061587. |
| Number | Date | Country | |
|---|---|---|---|
| 20230161975 A1 | May 2023 | US |
