CN103209267A

CN103209267A - Method and device for calling

Info

Publication number: CN103209267A
Application number: CN2013101442620A
Authority: CN
Inventors: 陆文乐; 刘建峰; 林剑亮; 庞健荣
Original assignee: Shenzhen Gongjin Electronics Co Ltd
Current assignee: Shenzhen Gongjin Electronics Co Ltd
Priority date: 2013-04-24
Filing date: 2013-04-24
Publication date: 2013-07-17
Anticipated expiration: 2033-04-24
Also published as: CN103209267B

Abstract

An embodiment of the invention discloses a method and device for calling. The method includes: firstly matching service codes, and then matching special numbers/common numbers after service code matching fails. Compared with the prior art, due to the fact that service code matching is independent, all numbers input by a user do not need to be matched with all rules when one number is input each time, and therefore efficient processing of the service codes can be achieved. In addition, when some service code is matched, an unsigned integer datum (unloaded by the numbers) is matched with unsigned integer datum corresponding to the service code, namely two unsigned integer data are matched, and matching speed is improved further.

Description

Calling method and device

Technical Field

The present invention relates to the field of communications technologies, and in particular, to a calling method and apparatus.

Background

Voip (voice over Internet Protocol) technology is to compress and package an analog voice signal, and then transmit the voice signal in the form of a data packet in an IP (Internet Protocol, abbreviated as IP) network environment.

VoIP has the same user experience as the traditional PSTN, and the basic call flow is as follows: the user dials on the analog phone, the VOIP terminal receives the number, and initiates a call to a server in the IP network and establishes the call.

Generally speaking, there are three categories of VoIP numbers:

number of ordinary call: here, the common numbers are abbreviated as "ordinary numbers", for example, fixed telephone numbers 020-xxxxxxxxxx, mobile telephone numbers 159xxxxxxxx, 800/400 numbers 12580, 17951xx, and the like in respective urban areas.

Service code: refers to a number that needs to be manually entered during a service to start the service or to enable/disable a locally implemented service. VOIP has a variety of supplementary services in addition to basic telephony, such as call forwarding, call waiting, three-way telephony, alarm clocks, malicious call tracking, pos card swiping, smart public telephony, and the like. Some supplementary services realized by the local terminal need to input a service code to enable/disable and start, some supplementary services need to send the service code out in secondary dialing after call establishment to perform service operation, some supplementary services have a series of authentication interaction processes before connection establishment, a service end can start a timer in the authentication interaction process, and if no response is received before the timer is overtime, the supplementary services fail.

Special numbers requiring quick number delivery: some services require the VOIP terminal to send these special numbers quickly before the timer expires. For example, when a POS (VOIP terminal) swipes a card, the POS may initiate a call to the service center, and at the same time, the POS may start a timer. After the service center is intercommunicated, a series of interactive authentications can be carried out through the media stream, if the number sending from the terminal to the service center is slow, the POS machine cannot receive the response from the service center before the timer is overtime, the service also fails, and therefore the dialing (special number) initiated by the POS machine to the service center needs to send the number quickly.

The service code generally does not exceed 8 numbers, while the normal number and the special number may be less than 8, and may exceed 8. Therefore, after receiving how many numbers, a call is initiated to the server, and the number matching (rule matching) of the VOIP terminal is required.

In the prior art, the service codes, the common numbers and the special numbers are uniformly matched in number, and every time a user inputs one number, all the numbers input by the user are matched with all rules. The matching mode can not meet the requirement of the market on efficient processing of the service codes.

Disclosure of Invention

In view of the above, an object of the embodiments of the present invention is to provide a calling method and apparatus to solve the above problem.

In order to achieve the above purpose, the embodiments of the present invention provide the following technical solutions:

according to a first aspect of the embodiments of the present invention, there is provided a calling method, including:

monitoring a user dialing event in a current dialing session;

when a dialing event of a user is monitored, acquiring a number input by the user during dialing;

when a first preset condition is met, at least all numbers collected in the current dialing session are transferred and stored as unsigned integer data, or when a second preset condition is met, at least all numbers collected in the current dialing session are transferred and stored as character string data;

when the first preset condition is met, performing corresponding bit matching on the unsigned integer data and unsigned integer data in a service code array set to obtain a matching result of successful service code matching, partial service code matching or failed service code matching, wherein the service code array set comprises a plurality of unsigned integer data, and each unsigned integer data corresponds to a preset service code;

when the second preset condition is met, special number/common number matching is carried out on the character string data, and at least matching results of successful special number matching, successful common number matching, partial common number matching or failed common number matching are obtained;

when the matching results of successful service code matching, successful special number matching, successful common number matching or failed common number matching are obtained, call control is carried out;

the first preset condition comprises that the final matching result of the service code is not obtained, the final matching result of the service code comprises the matching result of successful matching of the service code and the matching result of failed matching of the service code, and the second preset condition comprises that the matching result of failed matching of the service code is obtained.

With reference to the first aspect, in a second possible implementation manner, the special number/common number matching includes:

carrying out special number matching on the character string data to obtain a matching result of successful special number matching or failed special number matching;

and after a matching result of the special number matching failure is obtained, common number matching is carried out on the character string data, and a matching result of the common number matching success, the common number partial matching or the common number matching failure is obtained.

With reference to the first possible implementation manner of the first aspect, in a second possible implementation manner, the performing special number matching on the character string data includes:

matching the character string data with special number rule items in a special number figure rule set, wherein each special number rule item is character string data;

performing common number matching on the character string data comprises:

and matching the character string data with rule items in a basic number graph rule set, wherein the rule items in the basic number graph rule set comprise a common number rule item and a special number rule item, the special number rule item is positioned at the tail part of the common number rule item, and each rule item is character string data.

With reference to the first aspect, or the first possible implementation manner of the first aspect, or the second possible implementation manner of the first aspect, in a third possible implementation manner, the first preset condition and the second preset condition are represented by a condition identifier m2_ started, where when m2_ started takes a first value, the representation meets the first preset condition, and when m2_ started takes a second value, the representation meets the second preset condition.

With reference to the first aspect, in a fourth possible implementation manner, the call control includes:

when a matching result of successful service code matching is obtained, performing service logic processing by using the matched service code;

when a matching result of successful matching of the special numbers is obtained, all the numbers collected in the current dialing session are used for initiating a call;

and when a matching result of successful common number matching or failed common number matching is obtained, all the numbers collected in the current dialing session are used for initiating a call.

With reference to the first aspect, in a fifth possible implementation manner, the method further includes:

returning to the step of monitoring the user dialing event when a matching result of partial matching of the service codes is obtained;

and returning to the step of monitoring the user dialing event when a matching result of partial matching of the common number is obtained.

With reference to the second possible implementation manner of the first aspect, in a sixth possible implementation manner, the method further includes: initialization is performed.

With reference to the sixth possible implementation manner of the first aspect, in a seventh possible implementation manner, the initializing includes:

splitting the special number figure into special number rule items;

splitting the common number graph into common number rule items;

and constructing the service code array set, the special number figure rule set and the basic number figure rule set.

According to a second aspect of the embodiments of the present invention, there is provided a calling device, at least including: the system comprises a line control module, a service code matching module, a digital image analysis matching module and a call control module;

the line control module is used for monitoring a user dialing event in the current dialing session and acquiring a number input by the user during dialing when the dialing event of the user is monitored;

the service code matching module is used for at least enabling all numbers collected in the current dialing session to be transferred and stored as unsigned integer data when a first preset condition is met, or at least enabling all numbers collected in the current dialing session to be transferred and stored as character string data when a second preset condition is met, and carrying out corresponding bit matching on the unsigned integer data and unsigned integer data in a service code array set when the first preset condition is met to obtain a matching result of successful service code matching, partial service code matching or failed service code matching, wherein the service code array set comprises a plurality of unsigned integer data, and each unsigned integer data corresponds to a preset service code;

the digit and graph analysis matching module is used for matching the special number/common number of the character string data when the second preset condition is met, and at least obtaining the matching result of successful matching of the special number, successful matching of the common number, partial matching of the common number or failed matching of the common number;

the call control module is used for carrying out call control when the matching results of successful service code matching, successful special number matching, successful common number matching or failed common number matching are obtained;

the first preset condition comprises that the final matching result of the service codes is not obtained, the final matching result of the service codes comprises that the second preset condition comprises that the matching result of the service codes which are failed to be matched is obtained.

In a first possible implementation manner of the second aspect, the system further includes a configuration management module, where the configuration management module is configured to split the special number map into special number rule items; splitting the common number graph into common number rule items; and constructing the service code array set, the special number figure rule set and the basic number figure rule set.

It can be seen that in the embodiment of the present invention, the service codes are matched in advance, and the special number/common number matching is performed only after the service code matching fails. In addition, when a certain service code is matched, the unsigned integer data (unloaded by the number) is matched with the unsigned integer data corresponding to the service code, and the two unsigned integer data are matched in realization, so that the matching speed is further improved.

Drawings

In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the embodiments or the prior art will be briefly described below, it is obvious that the drawings in the following description are only some embodiments of the present invention, and for those skilled in the art, other drawings can be obtained according to the drawings without creative efforts.

Fig. 1 is a flowchart of a calling method according to an embodiment of the present invention;

fig. 2 is another flowchart of a calling method according to an embodiment of the present invention;

fig. 3 is another flowchart of a calling method according to an embodiment of the present invention;

fig. 4 is another flowchart of a calling method according to an embodiment of the present invention;

FIG. 5 is a schematic structural diagram of a calling device according to an embodiment of the present invention;

fig. 6 is a flowchart of cooperation between a service code matching module and other modules according to an embodiment of the present invention;

FIG. 7 is a flowchart illustrating a cooperation between a graph parsing and matching module and other modules according to an embodiment of the present invention;

fig. 8 is a schematic structural diagram of a calling device according to an embodiment of the present invention.

Detailed Description

The technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are only a part of the embodiments of the present invention, and not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.

A VOIP terminal is understood to be a gateway from a telephone network to an IP network, and a VOIP terminal is generally located in a home or a business and is a telephone access terminal device.

When the VOIP user dials in the analog phone, the VOIP receives the number, and the call to the server is initiated only when receiving the number, which is determined by the dialing rule existing in the VOIP terminal. And when the VOIP terminal receives one number, the number is matched by using the dialing rule.

As mentioned above, the VOIP number is divided into a service code, a general number and a special number.

Wherein, a common number has a series of regular expressions to represent dialing rules (i.e. number graph), for example:

The special numbers are the same as the ordinary numbers and correspond to the figure.

The service code is a pre-configured specific number which can be matched accurately, so that the service code does not correspond to a figure. The service codes are short, generally about 3 or 4 numbers, and can not exceed 8 numbers.

In the prior art, the service code, the common number and the special number are uniformly subjected to number matching, that is, the service code is put together with the rule items of the common number and the special number. Every time the user inputs one number, all the numbers input by the user need to be matched with all the rule items. If 100 service codes (i.e. service codes are also used as rule items) are put together with the rule items of the ordinary numbers and the special numbers, assuming that there are 100 rule items of the ordinary numbers and the special numbers respectively, then when number matching is performed, one third more rule items are added for comparison and matching.

In the prior art, all numbers input by the user are stored in a character string, for example, if the user inputs the number 123, 1, 2, and 3 would be stored as three characters, and the three characters 1, 2, and 3 would form a character string.

Correspondingly, the service code, the rule item of the common number and the rule item of the special number are also stored in the form of character strings. Taking the service code as an example, assuming that the service code is 12345, it is stored as a character string containing 5 characters.

Thus, when matching, one character is required for matching. Still taking the aforementioned user input number 123 as an example, when it is matched with the service code 12345, it is necessary to match the first character "1" in the character string "123" with the first character "1" in the service code character string "12345", match the second character "2" in the character string "123" with the second character "2" in the service code character string "12345", and match the third character "3" in the character string "123" with the third character "3" in the service code character string "12345", that is, it is necessary to match three times.

Similarly, if the user inputs the number "12345", it needs to be matched with the service code string "12345" five times.

Therefore, the existing matching mode can not meet the requirement of the market on efficient processing of the service codes.

In view of this, embodiments of the present invention provide a calling method and apparatus to solve the above problem.

When designing a service code, it is required that the service code cannot conflict with a normal number and a special number, and thus, the service code does not intersect with the normal number and the special number. By utilizing the point, the core of the embodiment of the invention is to separate the service code and separately process the service code matching and the special number/common number matching.

Based on the core idea, referring to fig. 1, the calling method at least includes the following steps:

s1, monitoring a user dialing event in the current dialing session;

s2, when a dialing event of a user is monitored, acquiring a number input by the user during dialing;

more specifically, the user presses a DTMF key and inputs a number. DTMF defines 16 keys (0-9, # a, B, C, D), and ordinary telephones use 0-9, # 12 keys, and the other 4 keys are used in some specific applications.

S3, when a first preset condition is met, at least all numbers collected in the current dialing session are transferred and stored as unsigned integer data, or when a second preset condition is met, at least all numbers collected in the current dialing session are transferred and stored as character string data;

and S4, when a first preset condition is met, carrying out corresponding bit matching on the unsigned integer data and unsigned integer data in the service code array set to obtain a matching result of successful service code matching, partial service code matching or failed service code matching.

The matching result of successful service code matching and the matching result of failed service code matching are the final service code matching results, and the partial service code matching is the intermediate service code matching result.

The service code array set comprises a plurality of unsigned integer data, and each unsigned integer data corresponds to a preset service code.

More specifically, the service code may be stored as unsigned integer data, with one number in the service code being stored every 4 bits (4 bits), the first number being stored in the lower 4 bits, and so on.

Taking the service code "12345678" as an example, the number "1" may be stored as "0001", the number "2" may be stored as "0010", the number "3" may be stored as "0011", the number "4" may be stored as "0100", the number "5" may be stored as "0101", the number "6" may be stored as "0110", the number "7" may be stored as "0111", and the number "8" may be stored as "1000". Then "12345678" may be stored as binary data: "10000111011001010100001100100001". It should be noted that, in the C language, the binary data "10000111011001010100001100100001" corresponds to an integer, such as a decimal integer 2271560481.

The numbers, #, a, B, C, D correspond to 1011,1100,1101,1110,1111,0000, respectively.

More specifically, the service code may be stored in an array unsigned int feature _ code [ ], where unsigned int denotes unsigned integer and feature _ code is an array name. The signaled animation _ code [ ] is the above-mentioned service code array set.

In addition, although the service codes are not more than 8 numbers, the length is not fixed, therefore, the length of each service code can be stored in the service code length array set signaled int feature _ code _ len [ ] (feature _ code _ len is an array name). For example, if the first member (i.e. the first unsigned integer data) in the feature _ code array set corresponds to service code 91, then the first member in the feature _ code _ len array set is 3.

The index of the first member in the feature _ code array set can be represented by an unsigned int feature _ code [ index ], and the length of the index of the first member in the feature _ code array set can be represented by an unsigned int feature _ code _ len [ index ].

And S5, when a second preset condition is met, performing special number/common number matching on the character string data to at least obtain a matching result of successful special number matching, successful common number matching, partial common number matching or failed common number matching.

And S6, when the matching results of successful service code matching, successful special number matching, successful common number matching or failed common number matching are obtained, call control is carried out.

Wherein: the first preset condition comprises that the final matching result of the service code is not obtained, and the second preset condition comprises that the matching result of the service code matching failure is obtained.

More specifically, the step S3 of "unloading all numbers collected in the current dialing session into an unsigned integer data" may include:

all numbers collected in the current dialing session are stored as 32-bit (32-bit) unsigned integer data, every 4 bits store a number dialed by a user, the first number input by the user is stored in the lower 4 bits, and so on.

For example, the user inputs the number "12580", wherein the number "1" may be stored as "0001", the number "2" may be stored as "0010", the number "5" may be stored as "0101", the number "8" may be stored as "1000", and the number "0" may be stored as "0000". Then "12580" may be stored as "00001000010100100001". Similarly, "00001000010100100001" in the C language corresponds to an integer.

More specifically, all numbers entered by the user in the current dialing session may be stored in a data structure unsigned int addr _ num, where unsigned int denotes unsigned integer and addr _ num is the data structure name.

Certainly, in practical application, a user inputs one number by one number, for example, the user has already input "125", at this time, data stored in the unidentified int addr _ num is "010100100001", if the user inputs "8", the "8" is converted into "1000" and stored in the unidentified int addr _ num, and data stored in the unidentified int addr _ num is "1000010100100001", and so on.

In addition, the number of numbers input by the user in the current dialing session can be stored at the same time, and the number is stored in the data structure signaled int digits _ len.

Based on the above storage method, when performing service code matching, the unsigned integer data in the unsigned int addr _ num can be compared with the unsigned integer data in the unsigned int feature _ code [ ] (service code array set).

Taking the unsigned integer data of the first index in the feature _ code array set as an example (namely, the service code of the first index), when the unsigned int bits _ len is equal to the unsigned int feature _ code _ len [ index ], directly judging whether the unsigned int addr _ num is equal to the unsigned int feature _ code [ index ], if so, the service code matching is successful, and if not, the service code matching is failed.

When the unsigned int flags _ len is smaller than the unsigned int feature _ code _ len [ index ], for example, the user inputs "123", and the service code corresponding to the unsigned integer data in the feature _ code array set is "12345", and then performs bit operation.

It should be noted that, the number "123" input by the user, the binary unsigned integer data converted by the conversion is "001100100001", and the binary unsigned integer data corresponding to the service code "12345" is "01010100001100100001", so called bit operation means that the last 12 bits of "01010100001100100001", that is, "001100100001", are compared with the binary unsigned integer data "001100100001" converted by "123", and if they are equal, the service code is partially matched, and if they are not equal, the service code matching fails.

No matter whether the signaled int flags _ len is equal to the signaled int feature _ code _ len [ index ], the signaled int addr _ num and the signaled int feature _ code [ index ] can obtain the matching result only by once numerical comparison.

In the prior art, if a user inputs a number 123, the number needs to be matched with a service code character string "12345" three times; if the user enters the number "12345", it needs to be matched five times with the service code string "12345". Compared with the prior art, the service matching method provided by the embodiment of the invention has relatively less consumption on the CPU and higher speed.

As for the "character string data" in the above-mentioned "cause all numbers collected in the current dialing session to be transferred as one character string data" in the step S3, may be stored in the array assigned char digits [ ]. Wherein the unsigned char represents the unsigned character and digits is the name of the array.

It should be noted that, because the service codes are no more than 8 numbers, are relatively simple, and need to be matched accurately, a data structure of unsigned int is used for storage. However, the number of the normal number and the special number may exceed 8, and therefore, it is not suitable to store the normal number and the special number by using an unsigned int data structure. Therefore, in the embodiment of the present invention, when the number input by the user is more than 8, the number input by the user is stored by using an unidentified char data structure.

And after the service code matching fails, adopting an unidentified char data structure to store whether the number input by the user exceeds 8 or not. Of course, since the service code does not exceed 8 numbers, there is no situation that the user can dial more than eight numbers and can match the service code.

Further, step S3 can be implemented in at least two ways.

The first mode is as follows: when a first preset condition is met, respectively transferring the number input by a user during dialing to an unidentified int addr _ num and unidentified char digits [ ]; when a second preset condition is met, only the number input by the user during dialing is saved to the signed char digits [ ];

the second way is: when the first preset condition is met, the number input by the user during dialing is transferred to the signed int addr _ num, and when the second preset condition is met, the data in the signed int addr _ num is transferred to the signed char digits [ ], and then if the user inputs the number again, the number input by the user is directly transferred to the signed char digits [ ].

The special number/general number matching when the second preset condition is satisfied will be described below.

The special number/common number matching may include:

carrying out special number matching on character string data in the signed char digits [ ] to obtain a matching result of successful special number matching or failed special number matching;

after the matching result of the special number matching failure is obtained, common number matching is carried out on the character string data in the signed char digits [ ], and the matching result of the common number matching success, the common number partial matching or the common number matching failure is obtained.

More specifically, the special number matching of the character string data in the unsigned char flags [ ] may include: and matching the character string data in the signed char digits [ ] with the special number rule items in the special number map rule set. Each special number rule item is character string data;

the above-mentioned common number matching for the character string data in the unsigned char flags [ ] may include: and matching the character string data in the signed char digits [ ] with the rule items in the rule set of the basic number graph. The rule items in the basic number graph rule set comprise a common number rule item and a special number rule item, the special number rule item is positioned at the tail of all the common number rule items, and the special number rule item and the common number rule item are both character string data.

It should be noted that when matching the character string data in the signed char flags [ ] with the special number rule item in the special number graph rule set or the rule item in the basic number graph rule set, character matching is performed.

In other embodiments of the present invention, referring to fig. 2, before monitoring the user dialing event, the method may further include:

and S0, executing initialization.

More specifically, referring to fig. 3, the initialization may include:

s01, splitting the special number graph into special number rule items;

s02, splitting the common number graph into common number rule items;

the execution order of step S02 and step S01 may be interchanged.

S03, constructing a service code array set, a special number figure rule set and a basic number figure rule set.

In other embodiments of the present invention, the step S03 may further include:

storing the pre-configured service code in an array unidentified int feature _ code [ ];

storing the normal number RULE item and the special number RULE item in an array MAP _ RULE _ T dmap [ ];

and constructing a special number graph RULE set and a basic number graph RULE set by using RULE items in the MAP _ RULE _ T dmap [ ].

After the special number/general number matching is introduced, call control will be described below.

In other embodiments of the present invention, the step S6 may specifically include:

when a matching result of successful matching of the service codes is obtained, executing service logic processing by using the service codes matched with the input number; the service logic processing may specifically include initiating a call, enabling a local service, or disabling a local service, which may be different according to different service code functions.

And when a matching result that the special numbers are successfully matched is obtained, all the numbers collected in the current dialing session are used for initiating a call.

Of course, after the common number matching fails, the call can be directly quitted without initiating the call.

In addition, in other embodiments of the present invention, referring to fig. 4, after the call control, the call method in all the embodiments may further include:

s7, session reset processing is performed.

Specifically, the session reset process may include at least: and releasing the current dialing session and starting a new dialing session.

Further, the above-described session reset process may further include performing the above-described initialization.

In other embodiments of the present invention, for convenience, the first preset condition and the second preset condition are represented by a condition identifier m2_ started, where m2_ started can take a first value and a second value (the first value is different from the second value), the first preset condition is satisfied when m2_ started takes the first value, and the second preset condition is satisfied when m2_ started takes the second value. More specifically, the first value may be false, 0, etc., and the second value may be true, 1, etc.

Accordingly, the session reset process in all the above embodiments may further include resetting m2_ started to be the first value, and clearing the unused int addr _ num and unused char bits [ ].

It should be noted that, in the process of performing service code matching and common number matching, there are matching results of partial matching besides successful matching (complete matching, which means that the number input by the user has been completely matched with a certain rule item/service code and there is no possibility of matching with other rule item/service code), and failed matching (the number input by the user cannot be matched with a certain rule item/service code).

Partial matching may include two cases:

in the first case, the number inputted by the user matches the front part of a certain rule item/service code, and the latter part needs to continue collecting numbers for matching, for example, the rule item/service code is 12580, and when the user only inputs 125 three numbers, it is a partial match.

The second case is that the number entered by the user has completely matched a certain rule item/service code, but there is also a possibility that other rule items/service codes may be matched. For example, there are two rule items/service codes 123 and 12345, the user input 123, which completely matches the rule item/service code of 123, but there is also the possibility that the user continues to dial to match the rule item/service code of 12345, which is also a partial match.

Based on this, the above method may further include:

and returning to the step of monitoring the user dialing event when a matching result of partial matching of the service codes is obtained.

And returning to the step of monitoring the dialing event of the user when a matching result of partial matching of the common number is obtained.

The main body of the calling method may be a calling device, and referring to fig. 5, the calling device may include a line control module M0, a service code matching module M1, a number map parsing matching module M2, a configuration management module M3, and a call control module M4. The M0-M4 modules may be logic modules or hardware modules, such as FPGA boards. When the M0-M4 module is a logic module, the calling device may include a CPU, a flash, and a memory in hardware.

The calling device may specifically be the VOIP device, or may be other devices that can implement the functions of the VOIP device, for example, the calling device may include a VOIP module, and the VOIP module may implement all the functions of the aforementioned M0-M4 modules.

The line control module M0 is mainly responsible for monitoring the VOIP physical line, such as on/off hook, dial, Flash, fax/Modem, etc., and controlling the operations of playing signal tone, ringing, playing and displaying, connecting DSP channel, etc.

The service code matching module M1 is mainly responsible for service code matching.

The number and graph analysis matching module M2 is mainly responsible for matching special numbers and common numbers. The 'analysis' in the figure and graph analysis matching module is embodied in that the module matches the number input by the user according to the figure and graph rules, and analyzes whether the number has the corresponding figure and graph rules which can be matched.

The configuration management module M3 is mainly responsible for performing initialization: the service code, the special number figure and the common number figure are used to construct the service code array set, the special number figure rule set and the basic number figure rule set.

The configuration management module M3 may initialize each time the calling device is started or the VOIP module is restarted separately, or modifying the VOIP related parameters may trigger the M3 module to initialize.

The call control module M4 is mainly responsible for processing the VOIP signaling related services, and also includes call control.

In the following, the technical solution of the present invention will be explained continuously by taking the module as the description granularity.

The service code matching module M1 is used as a leading role, and the service code matching aspect is mainly described in detail.

Referring to fig. 6, the cooperation process between the service code matching module M1 and other modules is as follows:

the configuration management module M3 initializes, and stores each service code to the signaled int feature _ code [ ] according to a format in which one number is stored every 4 bits from the lower 4 bits.

When the user goes off-hook, the line control module M0 transmits the off-hook event to the service code matching module M1. M1 initiates a new dialing session and initiates the associated data structure, including resetting the flag M2_ started to set M2_ started to the first value (false). When the value of M2_ started is a first value, the representation meets the first preset condition, and at this time, the number collected and reported by the M0 module is firstly subjected to service code matching in the service code matching module M1.

The user dials, and the M0 module detects the user dialing event and passes the dialing information (the number dialed by the user) to the service code matching module M1.

After receiving the dialing information, M1 first determines whether the current M2_ started flag is TRUE, and if it is FALSE, M1 performs the next processing, that is, forwards the numbers reported by M0 to two data structures, that is, the aforementioned unidentified int addr _ num and unidentified char bits, and records the number (also called length) of all the numbers input by the user in the current dialing session. If the number is TRUE, the M1 module forwards the number reported by M0 to the unsigned char flags [ ], and the unsigned char flags [ ] and unsigned int flags _ len are transferred to the number map parsing and matching module M2 for special number/common number matching.

After unloading, the service code matching module M1 resets the long timer. Resetting the long timer may include starting the long timer if the long timer is not started and clearing the long timer if the lengthy timer has been started. The long timer is also called a long between-digits timer, which represents the maximum time that the user can stay between dialing one number and dialing the next number. The long timer is reset here in order to wait for the user to continue dialing.

After the dump, the service code matching module M1 compares the number dumped into the unsigned int addr _ num with unsigned integer data in the unsigned int feature _ code [ ] (service code array set), so as to obtain a matching result of successful service code matching, partial service code matching or failed service code matching.

And when the unknown int flags _ len is smaller than the unknown int feature _ code _ len [ index ], performing the bit operation, if equal, the service codes are partially matched, and if not equal, the service codes are failed to be matched.

When the service code matching fails, the service code matching module M1 clears the long timer, and then transmits the unsigned char flags [ ] and the unsigned int flags _ len to the number map parsing matching module M2 for processing, and sets M2_ started as TRUE, and then the M1 does not process the dialing information of the user in the current dialing session and directly delivers the dialing information to the M2 for processing;

when the service code is completely matched successfully, if the service code is matched with the first index member in the feature _ code, the M1 transmits the index to the call control module M4, the M4 executes service logic processing, and meanwhile, the service code matching module M1 clears the long timer, releases the current dialing session, restarts a new dialing session, sets M2_ started to False, and clears signed int addr _ num, signed chardixits [ ] and signed int digits _ len;

when the service codes are partially matched, a long timer started/reset before is used for waiting for the continuous dialing of the user, if the long timer is overtime and no key input is carried out, the matching is processed as failure, M2_ started is set to be TRUE, the un-signed char digits [ ] and the un-signed int digits _ len are transmitted to M2 for analysis processing, and the M1 does not process the dialing information of the user in the current dialing session and directly transmits the dialing information to M2 for processing.

After the service code matching is introduced, the service code matching aspect is mainly introduced in detail by taking a figure analysis matching module M2 as a leading role.

After the data in the signed char flags [ ] is transmitted from M1 to M2, special number matching is firstly carried out in M2, and if the matching is successful, the call control module M4 is immediately called to initiate a call; and if the matching fails, the matching process is immediately carried out in the common number figure.

In the special number matching, the concept of partial matching does not exist, only two matching results of matching success and matching failure exist, and in the special number matching process, any timer cannot be started. If the matching of the current special number fails, the user inputs the number and the special number matching is firstly carried out. Therefore, as long as the special number is successfully matched, the special number is handed to the call control module M4 to initiate a call, so that the quick number sending can be realized, and the common number matching is not influenced after the special number matching fails. Since no timer is started in the special number matching, seamless connection can be performed with the common number matching.

And when the special number rule matching fails, carrying out common number matching. Common number matching is relatively complex. The matching result of the common number matching may include matching success, matching failure, and partial matching.

When the common number matching fails, the number and graph analysis matching module M2 releases the current dialing session, sets M2_ started as False, and informs the line control module M0 to release a signal prompt tone;

when the common numbers are successfully matched, the number and graph analysis and matching module M2 transmits all numbers input by the user to the M4 module to initiate a call, releases the current dialing session, and sets M2_ started as False;

when the common numbers are partially matched, the number graph parsing matching module M2 resets the corresponding timer (implemented inside M2) to wait for the user to continue dialing. Resetting the respective timer may include starting the timer if the respective timer is not started and clearing the timer if the timer has been started.

The digit map resolution matching module M2 can wait for the user to continue dialing by resetting the dmap _ timer. Note that the dmap _ timer is a global timer, and may be configured as a short timer or a long timer (inter-bit long timer).

It should be further noted that the common number matching has two modes of maximum matching and minimum matching, in the maximum matching mode, when the partial matching occurs, the map parsing matching module M2 sets the dmap _ timer as the short timer and starts it, and directly initiates the call after timeout. In the minimum matching mode, when the data is partially matched, the map parsing and matching module M2 sets the dmap _ timer as the bit length timer and starts the timer, and the call is directly initiated after the bit length timer is over time.

Referring to fig. 7, the cooperation flow between the map parsing and matching module M2 and other modules is as follows:

during software initialization or during updating of the number map configuration, the configuration management module M3 converts the special number map and the general number map into two rule sets: a special number graph rule set and a base number graph rule set.

When the user dials, the service code matching module M1 fails to match, the signed char flags [ ] and the signed int flags _ len are transmitted, and the M1 module initiates a number map analysis matching request.

The number-graph analysis matching module M2 firstly matches the character data in the unscented char digits [ ] with the rule items in the special number-graph rule set: traversing each rule item in the special number figure rule set, comparing whether one rule item is completely matched with the current dialing number, if not, matching failure of the special number is equivalent to matching failure of the special number, and then performing common number matching; if the complete matching is carried out and the special numbers are successfully matched, all numbers input by the user are transmitted to the call control module M4 to initiate a call, the current dialing session is released, a new dialing session is restarted, the unidentified int addr _ num, unidentified chardigits [ ] and unidentified int digits _ len are cleared, and M2_ started is set as False.

When the special number matching fails, M2 resets dmap _ timer to a long timer (i.e., a bit length timer) and starts it for normal number matching. The dmap _ timer is set to a long timer and functions to wait for entry of the next number possible and to proceed with the corresponding process shown in fig. 7 if no entry occurs over a time-out.

When common number matching is carried out, each rule item of the basic number graph rule set (the common number graph and the special number graph) is traversed, and whether one rule item completely matches with the current dialing number or not is compared.

If the matching is completely matched with one rule item, the common number is successfully matched, the dmap _ timer is cleared, all numbers input by the user are transmitted to the call control module M4 to initiate a call, the current dialing session is released, a new dialing session is restarted, the unused addr _ num, unused char _ digits [ ] and unused int digits _ len are cleared, and M2_ started is set as False;

if the partial match is one of the rule entries, the dmap _ timer is reset (in a different mode, the dmap _ timer is set to either the short timer or the long timer) and the user is awaited for subsequent dialing. It should be noted that, when M2_ started is TRUE, each user dialing is transmitted from M1, and M2 performs special number matching first and then performs normal number matching;

the call control may include notifying M0 to place a warning tone to indicate the failure of the matching, not initiating a call, or initiating a call using all numbers collected during the current dialing session. Subsequently, the current dialing session is released, a new dialing session is restarted, the unidentified addr _ num, unidentified char flags [ ] and unidentified int flags _ len are emptied, and m2_ started is set as False.

Now, it is explained in detail why the primitive number graph rule set includes a normal number rule item and a special number rule item, and the special number rule item is located at the tail of the normal number rule item: if the user inputs the special number, if the length of the number dialed by the user currently does not reach the length of the special number, the matching of the special number is failed. For example, assuming that the special number is 123456, the user currently only inputs 1234, and the matching fails in the service code matching process, and the M2 module is forwarded to match the special number. Since there is no partial match in the special number matching, the result of the special number matching performed at this time is a matching failure.

If the special number rule item is not added in the basic number graph rule set, the matching fails again in the following common number matching, at this time, the whole dialing session is ended, and the user cannot input a complete special number and initiate a call.

Therefore, the basic number diagram rule set must have special number rule items, so that the number dialed by the user is partially matched with the rule items in the basic number diagram rule set, and according to the above description, the M2 module will start a corresponding timer to wait for the user to continue inputting, so as to ensure that the user can input a complete special number and initiate a call.

In summary, according to the technical scheme provided by the embodiment of the present invention, the service code matching can be processed by only one primary cycle, which is more efficient than a secondary cycle uniformly put in the graph analysis matching, the special number matching does not need to wait for a timer, the matching can be dialed out immediately after the matching is successful, and the special number matching and the common number matching are seamlessly connected without mutual influence.

The first-stage loop of the above-described two-stage loop is a loop of each bit number in the feature _ code [ index ], and the second-stage loop is a loop of each feature _ code [ index ] in the feature _ code [ ]; in the embodiment of the invention, only the second stage of circulation is needed, so the second stage of circulation is a first stage of circulation.

In addition, in other embodiments of the present invention, the special number and the common number may be matched first, and then the service code may be matched. However, it is considered that the service code matching time is short, and the matching result can be obtained quickly, while the matching between the special number and the common number may take a long time to obtain the matching result. Therefore, the service code matching can be preferentially carried out, and the special number and the common number are matched after the matching fails.

Corresponding to the above-mentioned calling method, an embodiment of the present invention also intends to protect a calling device (VoIP apparatus), please refer to fig. 8, which at least includes: a line control module M0, a service code matching module M1, a figure parsing matching module M2 and a call control module M4. Wherein,

the line control module M0 is configured to monitor a user dialing event in a current dialing session, and when the user dialing event is monitored, collect a number input by the user during dialing;

the service code matching module M1 is configured to at least forward all numbers collected in the current dialing session to an unsigned integer data, or forward all numbers collected in the current dialing session to a character string data when a second preset condition is met, and match the unsigned integer data with unsigned integer data in the service code array set when the first preset condition is met, so as to obtain a matching result indicating that the service code matching is successful, the service code is partially matched, or the service code matching is failed;

the number-graph analysis matching module M2 is configured to, when a second preset condition is met, perform special number/common number matching on the character string data to obtain at least a matching result of successful special number matching, successful common number matching, partial common number matching, or failed common number matching;

the call control module M4 is configured to perform call control when a matching result indicating that the service code matching is successful, the special number matching is successful, the general number matching is successful, or the general number matching is failed is obtained.

In other embodiments of the present invention, the service code matching module M1 is further configured to, when a matching result of partial matching of the service codes is obtained, start a corresponding timer, and wait for a number acquired by the line control module M0 (i.e., the aforementioned step of returning to monitoring the user dialing event);

when a matching result of partial matching of the common number is obtained, a corresponding timer is started, and the number collected by the line control module M0 is waited (i.e. the aforementioned step of returning to monitoring the user dialing event).

For details, please refer to the description of the aforementioned method, which is not repeated herein.

In another embodiment of the present invention, still referring to fig. 5, the calling device may further include a configuration management module M3.

The configuration management module M3 may be configured to split the special number map into special number rule entries; splitting the common number graph into common number rule items; and constructing a service code array set, a special number figure rule set and a basic number figure rule set. For details, please refer to the description of the aforementioned method, which is not repeated herein.

The embodiments in the present description are described in a progressive manner, each embodiment focuses on differences from other embodiments, and the same and similar parts among the embodiments are referred to each other. For the device provided by the embodiment, the description is relatively simple because the device corresponds to the method provided by the embodiment, and the relevant points can be referred to the method part for description.

It is further noted that, herein, relational terms such as first and second, and the like may be used solely to distinguish one entity or action from another entity or action without necessarily requiring or implying any actual such relationship or order between such entities or actions. Also, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising an … …" does not exclude the presence of other like elements in a process, method, article, or apparatus that comprises the same element.

From the above description of the embodiments, it is obvious for those skilled in the art that the present invention can be implemented by software plus necessary general hardware, including general-purpose integrated circuits, general-purpose CPUs, general-purpose memories, general-purpose components, etc., or by special hardware including dedicated integrated circuits, dedicated CPUs, dedicated memories, dedicated components, etc., but the former is a better embodiment in many cases. Based on such understanding, the technical solutions of the present invention may be embodied in the form of a software product, and the computer software product may be stored in a readable storage medium, such as a usb disk, a removable storage medium, a Read-Only Memory (ROM), a Random Access Memory (RAM), a magnetic disk or an optical disk, and various media that can store software program codes, and include instructions for enabling a computer device (which may be a personal computer, a server, or a network device) to execute the method according to the embodiments of the present invention.

The previous description of the provided embodiments is provided to enable any person skilled in the art to make or use the present invention. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the generic principles defined herein may be applied to other embodiments without departing from the spirit or scope of the invention. Thus, the present invention is not intended to be limited to the embodiments shown herein but is to be accorded the widest scope consistent with the principles and novel features provided herein.

Claims

1. A method of calling, comprising:

monitoring a user dialing event in a current dialing session;

2. The method of claim 1, wherein the special number/normal number matching comprises:

3. The method of claim 2,

the special number matching of the character string data comprises the following steps:

performing common number matching on the character string data comprises:

4. The method according to any one of claims 1 to 3, wherein the first preset condition and the second preset condition are characterized by a condition identifier m2_ started, wherein the first preset condition is satisfied when the m2_ started takes a first value, and the second preset condition is satisfied when the m2_ started takes a second value.

5. The method of claim 1, wherein the call control comprises:

6. The method of claim 1, further comprising:

7. The method of claim 3, wherein prior to monitoring for a user dialing event, the method further comprises:

initialization is performed.

8. The method of claim 7, wherein the initializing comprises:

splitting the special number figure into special number rule items;

splitting the common number graph into common number rule items;

9. A calling device, comprising at least: the system comprises a line control module, a service code matching module, a digital image analysis matching module and a call control module;

10. The calling device of claim 9, further comprising a configuration management module configured to split a special number map into special number rule entries; splitting the common number graph into common number rule items; and constructing the service code array set, the special number figure rule set and the basic number figure rule set.