TWI459237B - Method for dynamically loading gesture algorithm for touch panel - Google Patents

Description

Dynamic loading method for gesture algorithm for touch panel

The invention relates to a touch panel, and more particularly to a dynamic loading method of a finger gesture algorithm applied to a touch panel.

With the evolution of technology, gesture touch has become the second choice for the output of capacitive touch panels. Each application's hand-style app often uses a variety of different gestures to manipulate the application, and in order to determine which gesture the user uses, various gesture algorithms have also been developed. In general, some touch panel manufacturers pre-program the number of gesture algorithms commonly used by users in firmware. The disadvantages are limited by the size of the firmware and the number of gesture algorithms supported. The advantage is that the speed is faster. In addition, some touch panel manufacturers use software directly for gesture algorithms. The advantage is that a large number of gesture calculations can be supported. The disadvantage is that it will occupy too much resources of the CPU or system, and the speed is obviously slower.

The present invention has been made in view of the above problems.

One of the objects of the present invention is to provide a dynamic loading method of a gesture algorithm to solve the above problems.

One of the objects of the present invention is to provide a dynamic loading method of a gesture algorithm capable of supporting a large number of hands in a case where the memory capacity is limited. Potential algorithm.

In order to achieve the above object, an embodiment of the present invention provides a method for dynamically loading at least one gesture algorithm into a multi-write memory, which is applicable to a mobile device, and the mobile device is provided with at least one A capacitive touch panel and a non-volatile memory device, wherein the capacitive touch panel is provided with at least a microcontroller and the memory that can be written multiple times, the method comprising the steps of: determining that a currently being Whether the open application has gestures; when the currently open application has gestures, it determines whether the space of the memory that can be written multiple times is sufficient; when the memory space is insufficient, according to a gesture algorithm The weight of at least one gesture of the code file, deleting at least one of the algorithm code sets of the at least one gesture, wherein the weight of each gesture algorithm is related to a startup sequence number of the corresponding application; when the memory space is Sufficiently, correspondingly reading from the non-volatile memory device according to at least one gesture used by the application currently being opened Potential code algorithm to generate a new set of algorithms gesture code file; and, the latest gesture algorithm code file written to the memory of multiple write.

The above and other technical contents, features and advantages of the present invention will be apparent from the following detailed description of the preferred embodiments.

General mobile devices have capacitive touch panels, and most capacitive touch panels on the market have microcontrollers (microcontrollers). Unit, MCU) and firmware to speed up the operation of gesture touch. One of the features of the present invention is that a gesture algorithm code file (a programming code set containing at least one gesture) is delivered to the microcontroller of the capacitive touch panel for execution, since the system is not occupied. CPU time and system resources, so the speed is fast. Another feature of the present invention is that as long as the user newly launches an application, the gesture algorithm code file can be dynamically updated and written into the multi-write memory of the capacitive touch panel (by means of touch The microcontroller of the control panel is executed), so although the capacity of the memory that can be written multiple times is limited, a large number of gesture algorithms can be supported.

Figure 1 is a diagram showing the flow of data between an application, a driver, and a memory of a capacitive touch panel within a mobile device in accordance with the present invention. Referring to FIG. 1 , a mobile device (not shown) has a capacitive touch panel 160 that supports a multi-touch function, and even if the user presses multiple points at the same time, the system can Also detected at the same time. The capacitive touch panel 160 includes at least a microcontroller 166, a non-volatile memory 164, and a write-once memory 162. The microcontroller 166 is configured to execute a firmware stored in the non-volatile memory 164 or a gesture algorithm code file 130 stored in the write-once memory 162 for gesture touch Control related operations.

When the mobile device's system is powered on, the operating system 150 is loaded, and then each driver (including the touch panel driver 110) is operational. Then, when the user opens the first application 140, The application 140 will first register with the operating system 150 and simultaneously report the basic data, including all gesture IDs that will be used, and the like. In the embodiment of Figure 1, when the application 140 registers, it reports that it will use five gestures (ID1~5). Then, the touch panel driver 110 is notified by the operating system 150 that an application 140 is currently loaded, and the touch panel driver 110 queries the operating system 150 to read and read the five gesture IDs used by the application 140. 1~5. As for the touch panel driver 110 and the operating system 150, the manner of querying and reading may be by a system application programming interface, a callback function, or a polling.

Then, the touch panel driver 110 sequentially reads the gesture algorithm code set stored in a non-volatile memory device 120 according to the gesture ID-1~5 to generate a gesture algorithm code file 130, and then The file 130 is written into the memory 162 of the touch panel 160 that can be written multiple times. Please note that in general, it takes time t for the user to open an application 140 to full load. Using this time t, the present invention also creates the file 130 and writes it into the memory 162 that can be written multiple times, so that the user does not feel a time difference.

The non-volatile memory device 120 can be, but is not limited to, a memory card, a read-only memory, a flash memory, and the like. The non-volatile memory device 120 includes at least two regions, that is, a start region and a code region (not shown). The size of the various gesture algorithm code sets and their addresses in the code area are pre-stored in the start area. And the pre-stored power in the code area All of the gesture algorithm code sets supported by the capacitive touch panel 160, for example, if the capacitive touch panel 160 supports one hundred gesture algorithms, the non-volatile memory device 120 stores a hundred gestures in advance. Algorithm code set. In addition, the size of each gesture algorithm code set depends on the complexity of each gesture algorithm. For example, the simple gesture algorithm code set size is less than 1K bytes, and the ten-finger complex gesture calculation The size of the legal code set may exceed 10K bytes.

The memory 162 that can be written multiple times can be, but is not limited to, a static random access memory (SRAM), a dynamic random access memory (DRAM), and a flash memory. Among the above three types of memory, only static random access memory can be integrated with the same chip on the microcontroller; in addition, the static random access memory has the fastest reading and writing speed, and the dynamic random access memory is slightly Slow, flash memory is the slowest (especially when writing, not only slow, but also special commands). The present invention utilizes the microcontroller 166 to execute the gesture algorithm code file 130 stored in the write-once memory 162. The memory 162 can be written multiple times due to a large number of mathematical operations. It is most suitable for implementation with static random access memory, which is not only easy to design, but also the most efficient and fastest.

Figures 2a and 2b show two formats of gesture algorithm code files according to the embodiment of Figure 1. Referring to FIG. 2a, the format of the gesture algorithm code file 130a includes a header 130a0 and at least one gesture algorithm code set 130a1~130aN (N is a positive integer greater than or equal to 1). Please refer to Figure 1 and Figure 2a at the same time, when the touch panel is driven Before the program 110 reads the gesture ID used by the application 140, it is first determined whether the gesture algorithm code file 130a already exists. If not, the header 130a0 is first established; if it is already present, the target is opened and updated. Head 130a0. Then, the touch panel driver 110 sequentially reads the gesture algorithm code set stored in the non-volatile memory device 120 according to the read gesture ID-1~5, and sequentially arranges the gesture algorithms. The code set is linked into a file 130a. The header 130a0 includes, but is not limited to, the total number of gesture algorithm code sets included in the current file 130a, the ID of each gesture algorithm, and the set of each gesture algorithm code set stored in the 130a1~a5 area. The address or pointer, the size of the current file 130a, and the remaining space of the currently multiplexable memory 162 (hereinafter referred to as the remaining space of the current memory) and the like.

The format of the gesture algorithm code file 130a of Fig. 2a is relatively straightforward, and the gesture algorithm code sets are directly arranged and linked into one file. However, observing these gesture manipulations can reveal some common behaviors such as acceleration, pressing, or sliding. In view of this, the present invention summarizes the common behavior between various gesture algorithms, and stores at least one corresponding algorithmic code set of the common behavior in the 130cb area, and the algorithm code set of the unique behavior of various gestures is further determined. The order is stored in 130b1~130bN (N is a positive integer greater than or equal to 1), as shown in Figure 2b. According to the embodiment of FIG. 1, if the touch panel driver 110 can generate two files 130a and 130b according to the same gesture ID-1~5, the size of the file 130b. It is usually smaller than the file 130a because the file 130b has extracted the corresponding algorithm code set of the common behavior and stored it in the 130cb area. As for the header 130b0, in addition to the content included in the header 130a0, the corresponding algorithm code set of each common behavior needs to be stored in the address or indicator of the 130cb area, so that the microcontroller 166 can successfully find the program. The code set is executed.

The circuit designer can select a suitable gesture algorithm code file format (130a or 130b) according to the read or write speed required by the system, and the hardware cost and design convenience of the memory 162 that can be written multiple times. And the size of the file, and the type and capacity of the memory 162 that can be written multiple times. According to the present invention, the latest launched application has the highest priority, and the gesture algorithm used should be all included in the gesture algorithm code file 130, so the circuit designer selects the gesture algorithm code file. The size and the size of the memory 162 that can be written multiple times should be appropriate, and should not be too small, otherwise the process of generating the gesture algorithm code file will be inefficient.

The following describes how the present invention dynamically updates the gesture algorithm code files (both applicable to file 130a and file 130b). To simplify the description, the following figures and embodiments only take the gesture algorithm code file 130a as an example, and assume that the memory 162 capacity that can be written multiple times is equal to 64K bytes and the gesture algorithm code The file size of the file 130a is set to be less than or equal to 64K bytes. Please note that the capacity of the above-mentioned multi-write memory 162 is equal to 64K bytes, and the gesture calculation The file size of the program code file 130 is set to be less than or equal to 64K bytes, and is merely an embodiment of the present invention, and is not a limitation of the present invention.

Figure 3 is a diagram showing the difference in the content of the gesture algorithm code file 130a before and after an application App-N is loaded, in accordance with the present invention. Referring to FIG. 3, before the application App-N is loaded, the gesture algorithm code file 130a contains only five algorithms ID sets of ID-1~ID-5 (time T). When the application App-N is loaded (time is T+1), since the application App-N uses five gestures, three of the gestures ID-1~ID-3 already exist in the file 130a. There are two kinds of gestures ID-14~ID-25 that are not yet in the file 130a. It is assumed that the touch panel driver 110 determines that the file 130a does not exceed the 64K byte even if the algorithm code set of the two hand ID-14~ID-25 is further included (the memory 162 that can be written multiple times) Capacity), the file 130a will be updated as shown (time T + 2).

Depending on the order in which the applications are launched, the operating system 150 will give each application a serial number. In other words, the larger the activation number of an application, the later the application is launched. In accordance with the present invention, the latest launched application has the highest priority and the gesture algorithms used must all be included in the gesture algorithm code file 130a. FIG. 4 illustrates a process in which the gesture algorithm code file 130a is dynamically incorporated into the gesture algorithm code set according to the activation sequence number of different applications according to an embodiment of the present invention.

In this embodiment, the touch panel driver 110 will give each type Gestures are weighted, and the weight is determined by the application's startup sequence number. If the same application is repeatedly turned on, the weight of the corresponding gesture is equal to the accumulation of the activation sequence number, for example, the weight of the gesture ID-4 is equal to (1+2=3). The exception is that the weight of the corresponding gesture of the latest open application is equal to infinity (indicating the highest priority, file 130a should contain all gestures used by the application).

Referring to FIG. 4, when only application App-1 is loaded (start sequence number is 1), file 130a contains only five gestures ID-1, ID-21, ID-35, ID-4, ID- 15 algorithmic code set. After that, when the application App-2 is also loaded (the startup sequence number is 2), since the gesture code of the gesture ID-4 and the ID-35 used by the application App-2 is already included in the file 130a, the touch The control panel driver 110 only needs to determine whether the archive 130a and the algorithm code set of the gesture ID-2 will exceed the 64K byte (the capacity of the write-once memory 162). If not, the file 130a will contain a total of six algorithmic code sets for gestures ID-1, ID-21, ID-35, ID-4, ID-15, ID-2. Finally, when the application App-3 is loaded (starting sequence number is 3), the algorithm code set of the gestures ID-1, ID-21, and ID-35 used by the application App-3 is already included in the file 130a. Therefore, the touch panel driver 110 only needs to determine whether the archive 130a is merged into the gesture ID-25, ID-14 algorithm code set will exceed 64K bytes. If not, the file 130a will contain a total of eight algorithmic code sets for gesture ID-1, ID-21, ID-35, ID-4, ID-15, ID-2, ID-14, ID-25. If it exceeds 64K bytes, the right in file 130a is removed first. The smallest gesture, in the embodiment of FIG. 4, the weights of the gestures ID-1, ID-21, ID-35, ID-14, and ID-25 of the latest application App-3 are equal to infinity. Large, and the weight of the gesture ID-15 is the smallest, so the priority is removed to accommodate the algorithm code set of the gesture ID-25, ID-14. If at least two gestures have the same weight minimum value, then according to the usage rate (refer to the description of FIG. 5), the gesture algorithm with lower usage rate is preferentially removed from the at least two gestures. The code set. And so on, until the archive 130a can be incorporated into the algorithmic code set of the gesture ID-25, ID-14 and will not exceed the 64K byte.

FIG. 5 illustrates an example of calculating the weight and usage rate of each gesture in the gesture algorithm code file 130a according to the activation sequence number and the gesture usage time of different applications according to the present invention. In the embodiment of FIG. 5, the touch panel driver 110 also gives each gesture a weight, and the weight is determined by the activation number of the application and the usage time of the gesture. Please refer to Figure 5, suppose that when the application App-3 is loaded (starting sequence number is 30), the system has four applications open (the application App-1 is opened twice, and other applications with the serial number are activated). It has been turned off), and the space of the write-once memory 162 is sufficient to accommodate six gesture algorithm codes. In this embodiment, the weights of the various gestures are equal to the activation sequence number of the corresponding application multiplied by the usage time (in seconds), for example, the weight of the gesture ID-3 is equal to the activation sequence number of the application App-2 multiplied by the usage time: 7 * 4=28. Similarly, the weight of the corresponding gesture for the latest open application is equal to infinity (indicating the highest priority) Right, file 130a should contain all the gestures used by the application. For example, the latest application ID-3 of the application App-3 has a weight equal to infinity. If the same application is repeatedly turned on, the weight of the corresponding gesture is equal to the sum of the activation sequence number and the usage time. For example, the weight of the gesture ID-1 is equal to (12×1+13×24)=324, and the gesture ID-2 The weight is equal to (5 × 1 + 19 × 24) = 461. Of course, later, if one of the same applications is closed (not shown), the weight of the corresponding gesture must be subtracted from the weight of the closed application. For example, suppose the application App-1 with the startup number equal to 1 is When off, the weight of gesture ID-1 is equal to 324-(12x1)=312, and the weight of gesture ID-2 is equal to 461-(5×1)=456.

In the embodiment of FIG. 5, if the user then opens the next application App-4 (a gesture is used, the figure is not shown), but the space of the memory 162 that can be written multiple times can no longer be accommodated. In a gesture algorithm code, the touch panel driver 110 rejects a gesture algorithm code set with a minimum weight according to the weight of various gestures. In the embodiment of Figure 5, the weight of gesture ID-3 is the smallest, so the priority is culled to accommodate the gesture algorithm code set of the next application. Assuming that at least two gestures have the same weight minimum value at this time, the touch panel driver 110 can compare the usage rates of the at least two gestures, and finally the gesture with the lowest usage rate is rejected. And so on, until the archive 130a can be incorporated into the algorithmic code set of all gestures of the application App-4 and will not exceed the 64K byte.

Please note that in this specification and the scope of patent application, "use The rate is defined as follows: the total usage time of a single gesture/the usage time of all gestures, where the unit of time is seconds. For example: gesture a, used a total of three times, the use time is 1 second, 2 seconds, 1 second; gesture b, used a total of two times, the use time is 2 seconds, 3 seconds; gesture c, only used Once, the usage time is 3 seconds. Therefore, the total usage time of gesture a is 4 seconds, the total usage time of gesture b is 5 seconds, the total usage time of gesture c is 3 seconds, and the total usage time of all gestures is 12 seconds. Therefore, the usage rate of gesture a is 33%, the gesture b is 42%, and the gesture c is 25%.

Figure 6 is a flow chart of the dynamic loading method of the gesture algorithm of the present invention. The present invention is used to dynamically load at least one gesture algorithm into a multi-write memory 162, which is suitable for a mobile device. The mobile device is provided with at least one capacitive touch panel 160 and a non-volatile memory. The body 120 has at least one microcontroller 166 and the memory 162 that can be written multiple times.

Prior to performing the method of the present invention, the system of the mobile device has been powered on, the operating system 150 has been loaded, and the touch panel driver 110 has also begun operation. In this embodiment, since the size of the write-once memory 162 for the gesture algorithm code file is dynamically equal to 64K bytes, the file size of the gesture algorithm code file 130 is set. Is less than or equal to 64K bytes. Hereinafter, the dynamic loading method of the gesture algorithm of the present invention will be described in detail based on FIGS. 1 and 6.

Step S602: Determine whether the user is currently opening an application. In the embodiment of Figure 1, when the user is currently opening an application At 140 o'clock, the application 140 first registers with the operating system 150 and simultaneously reports the basic data, including all the gesture IDs 1~5 that will be used. Next, the touch panel driver 110 is notified by the operating system 150 that an application 140 is currently loaded, and then proceeds to step S604. On the other hand, if the touch panel driver 110 is not notified by the operating system 150, this step is repeated.

Step S604: Determine whether the application has a usage gesture. As described above, after the touch panel driver 110 queries the operating system 150, for example, by using a call system application interface, a call back call function, or a polling method, the five used by the application 140 can be read. The gestures ID-1~5, after which, the process goes to step S606 to continue. On the other hand, if the value read by the touch panel driver 110 is equal to 0 or the operating system 150 does not respond, it indicates that the application does not use the gesture, and then returns to step S602.

Step S606: It is judged whether the file 130 already exists. If the application 140 is the first program opened by the user (starting sequence number = 1), the file 130 does not yet exist, and then, the process goes to step S614 to continue execution (as described above, at this time, the writeable multiple times The memory 162 capacity must be sufficient to accommodate all gestures used by the application (start sequence number = 1). Otherwise, the file 130 already exists and jumps to step S608 to continue execution.

Step S608: judging whether the file 130 needs to be updated according to all the gestures used by the last loaded application. The touch panel driver 110 compares the five gestures ID-1~5 and the gesture algorithm code file 130 one by one, and determines whether the five gestures ID-1~5 are included in the gesture algorithm. The code file is in the file 130. If the file 130 already contains all the gesture IDs -1~5 currently used by the application 140, the file 130 does not need to be updated, and then returns to step S602. On the other hand, if at least one gesture (assumed to be ID-1) is not included in the gesture algorithm code file 130, the file 130 must be updated, and then step S610 is performed.

Step S610: Determine whether the memory space is sufficient. The touch panel driver 110 reads the size of the gesture ID1 algorithm code set from the start region of the non-volatile memory device 120, and also reads the current memory in the header 130a or 130b of the file 130. The remaining space field. If the remaining space of the current memory is larger than the size of the algorithm code set of the gesture ID1, it indicates that the space of the memory 162 that can be written multiple times is enough to accommodate the algorithm code of the gesture ID-1, so skip to Step S614 continues with execution. Otherwise, it means that the space of the memory 162 that can be written multiple times is insufficient, and then jumps to step S612 for execution.

Step S612: Delete at least one gesture algorithm code set from the file 130. First, the weights of the various gestures already included in the file 130 are compared, and a gesture algorithm code set with the smallest weight is deleted. If at least two gestures have the same weight minimum value, continue to compare the usage rates of the at least two gestures, and delete a gesture algorithm code set with the lowest usage rate. Among them, the weight of each gesture is equal to the increment of the activation number of the relative application multiplied by the usage time of the gesture (please refer to the description of Figure 5).

Step S614: Generate a gesture algorithm code file 130. If the file 130 does not exist yet, the touch panel driver 110 may first establish the target. Head 130a0 or 130b0. Then, according to the gesture ID-1~5, the gesture algorithm code set stored in the non-volatile memory device 120 is sequentially read, and the gesture algorithm code sets are sequentially arranged to be connected into one file 130.

If the file 130 already exists and the gesture ID-1 is not included in the gesture algorithm code file 130, the touch panel driver 110 reads the gesture ID-1 algorithm code stored in the non-volatile memory device 120. The set, and the gesture ID-1 algorithm code set is arranged in the appropriate position of the file 130 to complete the update of the file 130.

Step S616: The file 130 is written into the memory 162 that can be written multiple times. After the touch panel driver 110 writes the file 130 to the write-once memory 162, all the steps of the dynamic loading method of the gesture algorithm of the present invention are completed.

The present invention has been described above by way of examples, and the scope of the present invention is not limited thereto, and various modifications and changes can be made by those skilled in the art without departing from the scope of the invention.

110‧‧‧Touch Panel Driver

120‧‧‧Non-volatile memory device

130, 130a, 130b‧‧‧ gesture algorithm code file

130a0, 130b0‧‧ ‧ header

130a1~a5‧‧‧ each gesture algorithm code set

130cb‧‧‧ at least one corresponding algorithm for the common behavior code set storage area

130b1~b7‧‧‧ Algorithms for the unique behavior of various gestures

140‧‧‧Application

150‧‧‧ operating system

160‧‧‧Capacitive touch panel

162‧‧‧Memory that can be written multiple times

164‧‧‧ Non-volatile memory

166‧‧‧Microcontroller

Figure 1 is a diagram showing the flow of data between an application, a driver, and a memory of a capacitive touch panel within a mobile device in accordance with the present invention.

Figures 2a and 2b show two formats of gesture algorithm code files according to the embodiment of Figure 1.

Figure 3 is a diagram showing the difference in the content of the gesture algorithm code file 130a before and after an application App-N is loaded, in accordance with the present invention.

FIG. 4 illustrates a process in which the gesture algorithm code file 130a is dynamically incorporated into the gesture algorithm code set according to the activation sequence number of different applications according to an embodiment of the present invention.

FIG. 5 illustrates an example of calculating the weight and usage rate of each gesture in the gesture algorithm code file 130a according to the activation sequence number and the gesture usage time of different applications according to the present invention.

Figure 6 is a flow chart of the dynamic loading method of the gesture algorithm of the present invention.

Claims (14)

A method for dynamically loading at least one gesture algorithm into a write-once memory for a mobile device, the mobile device having at least one capacitive touch panel and a non-volatile memory device The capacitive touch panel includes at least one microcontroller and the memory that can be written multiple times, and the method includes the following steps: determining whether an application currently being opened has a use gesture; when the current When the opened application has a gesture, it is determined whether the space of the memory that can be written multiple times is sufficient; when the memory space is insufficient, the at least one gesture weight of the gesture algorithm code file is deleted according to the weight of at least one gesture of the gesture algorithm code file. At least one of a set of algorithmic code sets, wherein the gesture algorithm code file file includes an algorithm code set of the at least one gesture, and the weight of each gesture is related to a startup sequence number of the corresponding application. When the memory space is sufficient, according to at least one gesture used by the currently open application, sequentially from the non-volatile memory And reading a corresponding gesture algorithm code set to generate an latest gesture algorithm code file; wherein the non-volatile memory device includes at least a start area and a code area; and wherein the start area is Pre-storing the size of each gesture algorithm code set and its address in the code area, and determining whether the space of the write-once memory is sufficient to: compare the currently open application The gesture used and the gesture contained in the gesture algorithm code file to determine whether the gesture algorithm code file needs to be updated; When the gesture algorithm code file needs to be updated, the start region of the non-volatile memory device is read to estimate a capacity of at least one gesture algorithm code set that has not been loaded, and the gesture algorithm code is read. The current memory remaining space field of the file, thereby comparing the current memory remaining space and the capacity of the unloaded gesture algorithm code set; and writing the latest gesture algorithm code file to the multiple times Write memory. The method described in claim 1 is implemented by a touch panel driver. The method as recited in claim 1, wherein the gesture algorithm code file further includes a header. The method as recited in claim 3, wherein the algorithm code set of each gesture in the gesture algorithm code file file includes at least one unique behavior gesture algorithm code set, and the calculation of each of the gestures The legal code set further includes an algorithm code set of at least one common behavior. The method of claim 1, wherein the size of the gesture algorithm code file is less than or equal to the capacity of the memory that can be written multiple times. The method of claim 1, wherein in the deleting step, at least one of the gesture algorithm code sets is deleted according to the usage rate of the gestures in the gesture algorithm code file. The method of claim 1, wherein the memory that can be written multiple times is a static random access memory (SRAM), a dynamic random access memory (DRAM), and a flash memory. One of them. The method of claim 1, wherein the step of determining whether the currently open application has a gesture comprises: determining whether a user is currently opening an application; when the user is currently opening The application queries an operating system for a gesture used by the application that is currently being opened; and determines whether the application currently being opened uses a gesture based on a return value of the operating system. The method of claim 8, wherein the query mode is one of a call system application interface (system API), a callback call function, and a polling. The method of claim 1, wherein when the corresponding application of the gesture of the gesture algorithm code file is only started once, the weight of the gesture is equal to the activation sequence number of the corresponding application. The method of claim 1, wherein when the corresponding application of the gesture of the gesture algorithm code file is activated more than once, the weight of the gesture is equal to the accumulation of the activation serial numbers of the corresponding applications. value. The method as recited in claim 1, wherein the weight of each of the gestures is more related to the usage time of each of the gestures. . The method of claim 12, wherein when the corresponding application of the gesture of the gesture algorithm code file is activated more than once, the weight of the gesture is equal to the activation sequence number of the corresponding application. This gesture uses the accumulated value of time. The method of claim 12, wherein when the corresponding application of the gesture of the gesture algorithm code file is only started once, the weight of the gesture is equal to the startup serial number of the corresponding application multiplied by Gesture usage time.