CN109739779B - Method for acquiring available storage space in java card, computer device and computer readable storage medium - Google Patents
Method for acquiring available storage space in java card, computer device and computer readable storage medium Download PDFInfo
- Publication number
- CN109739779B CN109739779B CN201910012887.9A CN201910012887A CN109739779B CN 109739779 B CN109739779 B CN 109739779B CN 201910012887 A CN201910012887 A CN 201910012887A CN 109739779 B CN109739779 B CN 109739779B
- Authority
- CN
- China
- Prior art keywords
- variable
- value
- storage space
- java card
- instruction
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
Images
Classifications
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Landscapes
- Stored Programmes (AREA)
- Devices For Executing Special Programs (AREA)
Abstract
The invention provides a method for acquiring available storage space in a java card, a computer device and a computer readable storage medium, wherein the method comprises the steps of receiving and executing a selection instance instruction, judging whether a last allocation storage space flag bit is set, if so, setting a first variable and a second variable, setting the allocation storage space flag bit, applying a buffer, setting a second preset threshold value for the size of the allocable storage space of the buffer, executing a preset circulation instruction, allocating the storage space of the preset size to the buffer, judging whether the allocation process is successful or not, if the allocation process fails, reducing the value of the second variable, and returning to execute the circulation instruction. The invention also provides a computer device and a computer readable storage medium of the method. The method and the device can obtain the size of the available storage space in the java card more accurately.
Description
Technical Field
The invention relates to the field of smart cards, in particular to a method for acquiring available storage space in a java card, a computer device and a computer readable storage medium.
Background
Smart cards such as entrance guard cards, bank cards, bus cards, etc. are widely used in daily life of people, wherein a java card is a CPU smart card capable of running java programs, and the development of smart card applications is simplified due to the advent of the java card.
In the field of java cards, the global general specification of the java card is the global platform specification, but the global platform specification does not give an instruction for clearly acquiring the residual storage space of the java card, so that a user cannot clearly grasp the residual space when using the java card, trouble is brought to the processes of personalized card issuing and card debugging, unpredictable errors caused by insufficient storage space of the card often occur, error reasons are found by the user, the workload of the user is increased, and the work efficiency of the user when carrying out related operations of the smart card is reduced.
Although in the GlobalPlatform specification, the Java card has a function interface public static short getAvailableMemory in the API interface facing the user, the user can send related instructions to the Java card through the function interface, and then acquire data sent by the Java card, namely the size of the remaining storage space in the Java card, the type of the data acquired by the user through the function interface is short, so that the maximum size of the remaining storage space in the Java card can only be acquired to be 32K, and therefore, certain limitation exists.
Disclosure of Invention
The first object of the invention is to provide a method for obtaining the available storage space in the java card more accurately.
A second object of the present invention is to provide a computer device capable of implementing the above-mentioned method for obtaining the available storage space in a java card.
A third object of the present invention is to provide a computer readable storage medium capable of implementing the above-mentioned method of obtaining the available storage space in a java card.
In order to achieve the first objective, the method for obtaining the available storage space in the java card provided by the invention comprises the steps of receiving an instance selection instruction and executing, judging whether a flag bit of the storage space allocated for the last time is set, if yes, setting a first variable and a second variable, calling an API interface to obtain the value of the residual storage space in the interior and giving the value to the first variable; judging whether the value of the first variable is smaller than a preset first threshold value, if so, giving the value of the first variable to the second variable; setting the allocated storage space flag bit, applying for a buffer, setting a second preset threshold value for the size of the allocable storage space of the buffer, executing a preset circulation instruction, allocating the storage space of the preset size to the buffer, judging whether the allocation process is successful or not, reducing the value of the second variable once if the allocation process fails, and returning to execute the circulation instruction after setting the allocated storage space flag bit and the last allocated storage space flag bit; if the allocation process is successful, the execution of the select instance instruction is ended, and the value of the second variable obtained after the execution of the select instance instruction is the value of the size of the storage space allocated to the buffer.
According to the scheme, after a java card can receive a selection instance instruction and execute the selection instance instruction, whether the card has a residual space or not is judged by judging whether a last storage space allocation flag bit is set, if the card has the residual space, a first variable and a second variable are set, the value of the internal residual storage space is obtained through an API interface and is given to the first variable, the value of the first variable is given to the second variable if the value of the first variable is smaller than a preset first threshold value, a buffer is applied, the storage space with the preset size is allocated to the buffer, the value of the storage space with the preset size is the value of the second variable, if the storage space allocation failure is caused by insufficient storage space in the allocation process, the value of the second variable is larger than a second preset threshold value, the allocation failure is indicated, and if the value of the second variable is smaller than or equal to the second preset threshold value, the value of the second variable is obtained finally, the value of the storage space with the preset size is obtained.
After receiving the selection instance instruction sent by the user terminal, the user terminal sends the value of the second variable obtained after executing the selection instance instruction to the user terminal until the user terminal detects that the value of the second variable is 0, the user terminal finishes sending the selection instance instruction, and the user terminal accumulates the value of one second variable received after sending the selection instance instruction each time.
The method comprises the steps that a user terminal sends an instance selection instruction to a java card once, the value of a second variable can be received once, the instance selection instruction sent to the java card is ended until the user terminal detects that the received value of the second variable is 0, and the value of one second variable received by each instance selection instruction is accumulated, so that the available storage space of the java card can be acquired more accurately.
Further, the sending the value of the second variable to the user terminal includes: after converting the value of the second variable into an APDU command sequence, sending the APDU command sequence to the user terminal.
It can be seen that the information unit transmitted between the user terminal and the java card is an APDU command sequence, and the java card converts the value of the second variable into the APDU command sequence and then can transmit the value to the user terminal.
Before sending the value of the second variable to the user terminal, after the user terminal detects that the value of the second variable is 0, the method comprises the following steps: the user terminal receives the APDU instruction sequence and extracts the value of the second variable in the APDU instruction sequence.
It can be seen that the user terminal needs to extract the value of the second variable in the received APDU command sequence, so as to read the value of the second variable.
Further, before receiving the instruction of selecting an instance and executing, the method comprises the following steps: and receiving an execution file and downloading the execution file to the application module, wherein the execution file is used for executing the received selection instance instruction.
Therefore, before the java card receives the instance selection instruction, the file CAP packet needs to be executed up and down on the application module APPLET of the java card, so that the java card can receive the instance selection instruction sent by the user terminal.
If the value of the first variable is judged to be larger than the preset first threshold, the preset first threshold is given to the first variable, the marker bit of the distributed storage space is set, a buffer is applied, a second preset threshold is set for the size of the distributed storage space of the buffer, and a preset circulating instruction is executed.
Therefore, since the size of the memory space which can be allocated to the buffer is fixed, in order to avoid that the value of the second variable is too large, the calculated amount of the process of allocating the memory space to the buffer by executing the loop instruction is too large, and the value of the second variable is set to be the size of the memory space which is allocated at one time, namely the first preset threshold value, so as to accelerate the process of allocating the memory space to the buffer by executing the loop instruction.
Further, the method comprises the following steps of: and deleting the execution file downloaded to the application module.
After the execution of the instance selection instruction is finished, the execution file CAP downloaded to the application module APPLET is deleted, so that the occupation of the available storage space in the java card is avoided.
Still further, reducing the value of the second variable once comprises: the value of the second variable is reduced in units of one byte.
It can be seen that, in order to obtain the value of the second variable obtained after executing the selection instance instruction more accurately, the value of the second variable is reduced by one byte, so that the error is further reduced.
In order to achieve the second object, the present invention further provides a computer device, which includes a processor and a memory, wherein the memory stores a computer program, and the computer program when executed by the processor implements the steps of the method for obtaining the available storage space in the java card.
In order to achieve the third object, the present invention further provides a computer readable storage medium having a computer program stored thereon, where the computer program, when executed by a processor, implements the steps of the method for obtaining the available storage space in a java card.
Drawings
FIG. 1 is a first flow chart of an embodiment of a method of the present invention for obtaining the available memory space of a java card.
FIG. 2 is a second flow chart of an embodiment of a method of the present invention for obtaining the available memory space of a java card.
The invention is further illustrated by the following examples in conjunction with the accompanying drawings.
Detailed Description
The method for acquiring the available storage space in the java card is applied to terminal equipment capable of sending instructions to the java card, and is typically applied to terminal equipment such as a card writer. The computer device of the present invention may be the above-described electronic apparatus, and the computer-readable storage medium may be various storage media having a data storage function, such as a nonvolatile memory FLAASH, EEPROM.
The embodiment of the method for acquiring the readable storage space in the java card comprises the following steps:
referring to fig. 1, an interaction between a java card and a user terminal is described. The method comprises the steps of firstly executing step S1, receiving an execution file by the java card, and downloading the execution file to an application module in the java card. For example, the execution file CAP packet is received and downloaded to the application module application, so that the java card can receive and execute the instruction of selecting an instance, and can feed back the data of the available storage space in the card to the terminal sending the instruction.
Then, step S2 is executed, and the user terminal sends an instance selection instruction to the java card. Thus, the user terminal starts to acquire the available storage space in the java card.
Then, step S3 is executed, where the user terminal receives the value of the second variable sent by the java card. For example, after receiving the instruction of selecting an instance, the java card sends the value of the second variable to the user terminal, that is, feeds back the data of the available storage space in the card to the user terminal. The information unit transmitted between the user terminal and the java card is an APDU command sequence, so the java card converts the value of the second variable obtained after executing the selection instance command into the APDU command sequence, and then sends the APDU command sequence to the user terminal.
Then, step S4 is performed, and the user terminal detects and determines whether the received value of the second variable is 0. The user terminal can determine whether the available storage space exists in the java card by detecting and judging whether the value of the received second variable is 0. If the user terminal detects and judges that the value of the received second variable is not 0, the user terminal continues to send an instance selection instruction to the java card. After receiving the APDU command sequence sent by the java card, the user terminal provides the value of the second variable in the APDU command sequence.
And if the user terminal detects and judges that the received value of the second variable is 0 and the storage space in the java card is not available, executing step S5, and accumulating the value of one second variable received after each instance of the selection instance instruction sent to the java card by the user terminal to obtain the available storage space in the java card.
And finally, executing step S6, wherein the user terminal sends an ending instruction to the java card and deletes the execution file downloaded to the application module. Because the execution file CAP package of the application module actually occupies about 200 bytes of space, the execution file CAP package downloaded to the application module APPLET needs to be deleted after the available storage space in the java card is obtained.
Specifically, referring to fig. 2, a process of how the java card sends a value of the second variable to the user terminal after receiving a selection instance instruction is described.
After the user terminal sends an instance selection instruction to the java card, the java card firstly executes step S11, receives the instance selection instruction and executes the instance selection instruction.
Next, the java card executes step S12 to determine whether the last allocated storage space flag bit is set. The java card is internally provided with a last storage space marker bit, and if the last storage space marker bit is set, the java card is free of available storage space; and if the last storage space flag bit is not set, indicating that the available storage space exists in the java card.
Next, the java card executes step S13 to set the first variable and the second variable, call the API interface to obtain the value of the remaining storage space, and assign the value to the first variable. For example, a first variable FreeSize and a second variable AllotSize are set in the java card, and the value of the residual space in the java card is obtained through an API interface JCS system.
Next, the java card executes step S14 to determine whether the value of the first variable is less than a preset first threshold. For example, the size of the one-time allocation storage space, that is, the first preset threshold value is set to be 20K, so that the value given to the second variable does not exceed the size of the one-time allocation storage space, and of course, the size of the first preset threshold value can be set by a user according to actual situations, and if the user does not set the size of the first preset threshold value, the system in the java card defaults to 20K.
Then, if the value of the first variable is determined to be smaller than the preset first threshold, and the value of the first variable does not exceed the size of the one-time allocated storage space, the java card executes step S15 to set the flag bit of the allocated storage space, apply for a buffer, and set a second preset threshold for the size of the storage space that can be allocated by the buffer. And an allocation storage space flag bit is arranged in the java card, and if the allocation storage space flag bit is set, the allocation of the storage space in the java card is performed once. Applying for a buffer, since the size of the allocable storage space of the buffer can be set according to actual needs, setting a second preset threshold for the size of the second allocable storage space of the buffer, for example, setting the first preset threshold to 20K, setting the second preset threshold to 15K if the value of the first variable is smaller than the first threshold, and if the value of the first variable exceeds the second preset threshold, the allocation process of allocating the value of the allocable storage space to the buffer cannot be successful.
If the value of the first variable is judged to be smaller than the preset first threshold value, the preset first threshold value is given to the second variable, and the value given to the second variable does not exceed the size of the one-time allocation storage space, so that the process of allocating the storage space to the buffer by the subsequent execution cycle instruction is quickened.
Then, the java card executes step S16 to execute a preset loop instruction, for example, the java card executes a While loop instruction, and determines that the allocation space flag bit is set, and then performs a process of allocating storage space to the buffer.
Then, the java card performs step S17 to allocate a storage space of a preset size to the buffer, where the size of the storage space of the buffer is the value of the second variable.
Next, the java card executes step S18 to determine whether the allocation process is successful. In the process of allocating the value of the storage space to the buffer, capturing the size of the allocatable storage space of the buffer, that is, the value of the first preset threshold value smaller than the second variable in an abnormal capturing manner, can cause the occurrence of a throwing abnormality caused by insufficient allocatable storage space of the buffer, and the allocation process fails.
If the java card judges that the allocation process fails, step S21 is executed to reduce the value of the second variable once, and set the allocated storage space flag bit and the last allocated storage space flag bit. For example, the value of the second variable may be reduced one time in bytes such that the process of reducing the value of the second variable to just the size that allocates memory to the buffer can succeed, i.e., the value of the second variable is just equal to the second preset threshold size.
Finally, if the java card judges that the allocation process is successful, the java card executes step S19 to end executing the selection instance instruction, and the value of the second variable obtained after executing the selection instance instruction is the value of the size of the storage space allocated to the buffer. For example, the value of the second variable obtained after the java card passes through the detection buffer to execute the selection instance instruction once is the value of the storage space size.
Therefore, in the embodiment, the user terminal continuously sends the selection instance instruction to the Java card, receives the data sent by the Java card, and adds up the data sent by the Java card and received with the selection instance instruction each time to obtain the available storage space in the Java card. And in the process of executing the selection instruction by the java card, determining whether an available storage space exists in the java card by judging whether a last storage space allocation flag bit in the java card is set, and judging whether the value of a second variable is smaller than or equal to a first preset threshold value by allocating a storage space with a preset size to a buffer, namely, finally obtaining the value of the second variable after executing the selection implementation instruction and sending the value of the second variable to the user terminal.
Computer apparatus embodiment:
the computer device of the present embodiment includes a processor, a memory, and a computer program stored in the memory and executable on the processor, for example, an information processing program for realizing the above-described information processing method. The processor executes the computer program to implement the steps of the method for obtaining the available storage space in the java card.
For example, a computer program may be split into one or more modules, which are stored in memory and executed by a processor to perform the various modules of the invention. One or more of the modules may be a series of computer program instruction segments capable of performing specific functions for describing the execution of the computer program in the terminal device.
It should be noted that the terminal device may be a computing device such as a desktop computer, a notebook computer, a palm computer, a cloud server, and the like. The terminal device may include, but is not limited to, a processor, a memory. It will be appreciated by those skilled in the art that the schematic diagram of the present invention is merely an example of a terminal device and is not limiting of the terminal device, and may include more or less components than those illustrated, or may combine some components, or different components, e.g., the terminal device may also include an input-output device, a network access device, a bus, etc.
The processor referred to in the present invention may be a central processing unit (Central Processing Unit, CPU), or other general purpose processor, digital signal processor (Digital Signal Processor, DSP), application specific integrated circuit (Application Specific Integrated Circuit, ASIC), off-the-shelf programmable gate array (Field-Programmable Gate Array, FPGA) or other programmable logic device, discrete gate or transistor logic device, discrete hardware components, or the like. The general purpose processor may be a microprocessor or the processor may be any conventional processor or the like, the processor being a control center of the terminal device, and the various interfaces and lines being used to connect the various parts of the overall terminal device.
The memory may be used to store computer programs and/or modules, and the processor may implement various functions of the terminal device by running or executing the computer programs and/or modules stored in the memory, and invoking data stored in the memory. The memory may mainly include a storage program area and a storage data area, wherein the storage program area may store an operating system, an application program (such as a sound playing function, an image playing function, etc.) required for at least one function, and the like; the storage data area may store data (such as audio data, phonebook, etc.) created according to the use of the handset, etc. In addition, the memory may include high-speed random access memory, and may also include non-volatile memory, such as a hard disk, memory, plug-in hard disk, smart Media Card (SMC), secure Digital (SD) Card, flash Card (Flash Card), at least one disk storage device, flash memory device, or other volatile solid-state storage device.
Computer-readable storage medium:
the modules integrated in the terminal device may be stored in a computer readable storage medium if implemented in the form of software functional units and sold or used as a stand alone product. Based on such understanding, the present invention may implement all or part of the procedures in the methods of the above embodiments, or may be implemented by a computer program for instructing related hardware, where the computer program may be stored in a computer readable storage medium, and the computer program may implement the steps of the methods for starting the respective imaging processes when executed by a processor.
Wherein the computer program comprises computer program code, which may be in the form of source code, object code, executable files or in some intermediate form, etc. The computer readable medium may include: any entity or device capable of carrying computer program code, a recording medium, a U disk, a removable hard disk, a magnetic disk, an optical disk, a computer Memory, a Read-Only Memory (ROM), a random access Memory (RAM, random Access Memory), an electrical carrier signal, a telecommunications signal, a software distribution medium, and so forth. It should be noted that the content of the computer readable medium can be appropriately increased or decreased according to the requirements of the jurisdiction's jurisdiction and the patent practice, for example, in some jurisdictions, the computer readable medium does not include electrical carrier signals and telecommunication signals according to the jurisdiction and the patent practice.
It should be noted that the foregoing is only a preferred embodiment of the present invention, but the design concept of the present invention is not limited thereto, and any insubstantial modifications made to the present invention by using the concept fall within the scope of the present invention.
Claims (10)
1. A method for obtaining available memory space in a java card, comprising:
receiving an instance selection instruction and executing the instance selection instruction, judging whether a flag bit of the last storage space allocation is set, if so, setting a first variable and a second variable, calling an API interface to acquire the value of the internal residual storage space and giving the value to the first variable;
judging whether the value of the first variable is smaller than a preset first threshold value, if so, giving the value of the first variable to the second variable;
setting a storage space allocation zone bit, applying for a buffer, setting a second preset threshold value for the size of the storage space which can be allocated by the buffer, executing a preset circulation instruction, allocating the storage space with the preset size to the buffer, judging whether the allocation process is successful or not, reducing the value of the second variable once if the allocation process fails, and returning to execute the circulation instruction after setting the storage space allocation zone bit and the storage space allocation zone bit which are allocated last time;
and if the allocation process is successful, ending executing the selection instance instruction, wherein the value of the second variable obtained after executing the selection instance instruction is the value of the size of the storage space allocated to the buffer.
2. The method for obtaining the available storage space in the java card according to claim 1, comprising:
after receiving an instance selection instruction sent by a user terminal, sending a value of a second variable obtained after executing the instance selection instruction to the user terminal until the user terminal detects that the value of the second variable is 0, ending sending the instance selection instruction by the user terminal, and accumulating the value of the second variable received after sending the instance selection instruction each time by the user terminal.
3. The method for obtaining the available storage space in the java card according to claim 2, comprising:
the user terminal ending sending the selection instance instruction comprises the following steps: and the user terminal sends an ending instruction to the java card, and the java card deletes the execution file downloaded to the application module after receiving the ending instruction.
4. A method of obtaining available memory space in a java card as claimed in claim 3, comprising:
transmitting the value of the second variable to the user terminal includes: and after converting the value of the second variable into an APDU instruction sequence, sending the APDU instruction sequence to the user terminal.
5. The method for obtaining the available memory space in the java card of claim 4, comprising:
before sending the value of the second variable to the user terminal, after the user terminal detects that the value of the second variable is 0, the method comprises the following steps: the user terminal receives the APDU command sequence and extracts the value of the second variable in the APDU command sequence.
6. A method of obtaining available memory space in a java card according to claim 1 or 2, comprising:
before receiving and running the selection instance instruction, the method comprises the following steps: and receiving an execution file and downloading the execution file to the application module, wherein the execution file is used for executing the received selection instance instruction.
7. A method of obtaining available memory space within a java card according to any one of claims 1 to 5, comprising:
if the value of the first variable is judged to be larger than the preset first threshold, the preset first threshold is given to the first variable, the mark position of the distributed storage space is set, a buffer is applied, a second preset threshold is set for the size of the distributed storage space of the buffer, and a preset circulating instruction is executed.
8. A method of obtaining available memory space within a java card according to any one of claims 1 to 5, comprising:
said decreasing once the value of the second variable comprises: the value of the second variable is decremented by one byte.
9. Computer device, characterized in that it comprises a processor and a memory, said memory storing a computer program which, when executed by the processor, implements the steps of a method of obtaining the available memory space in a java card according to any of claims 1 to 8.
10. A computer readable storage medium having stored thereon a computer program characterized by: the computer program, when executed by a processor, performs the steps of a method of obtaining available memory space within a java card as claimed in any one of claims 1 to 8.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910012887.9A CN109739779B (en) | 2019-01-07 | 2019-01-07 | Method for acquiring available storage space in java card, computer device and computer readable storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910012887.9A CN109739779B (en) | 2019-01-07 | 2019-01-07 | Method for acquiring available storage space in java card, computer device and computer readable storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN109739779A CN109739779A (en) | 2019-05-10 |
| CN109739779B true CN109739779B (en) | 2023-04-21 |
Family
ID=66363674
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201910012887.9A Active CN109739779B (en) | 2019-01-07 | 2019-01-07 | Method for acquiring available storage space in java card, computer device and computer readable storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN109739779B (en) |
Families Citing this family (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN115048256B (en) * | 2022-08-16 | 2022-11-29 | 北京智芯半导体科技有限公司 | Test method, test system, and computer-readable storage medium |
| CN115048317B (en) * | 2022-08-16 | 2022-11-29 | 北京智芯半导体科技有限公司 | Test method, test system, and computer-readable storage medium |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7110415B1 (en) * | 2002-05-17 | 2006-09-19 | Marvell International Ltd. | Apparatus and method for dynamically limiting output queue size in a quality of service network |
| CN102521094A (en) * | 2011-11-28 | 2012-06-27 | 飞天诚信科技股份有限公司 | Method for initializing java card and java card |
| CN106155930A (en) * | 2015-02-17 | 2016-11-23 | 邻客音公司 | The memory cache of application layer management |
-
2019
- 2019-01-07 CN CN201910012887.9A patent/CN109739779B/en active Active
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7110415B1 (en) * | 2002-05-17 | 2006-09-19 | Marvell International Ltd. | Apparatus and method for dynamically limiting output queue size in a quality of service network |
| CN102521094A (en) * | 2011-11-28 | 2012-06-27 | 飞天诚信科技股份有限公司 | Method for initializing java card and java card |
| CN106155930A (en) * | 2015-02-17 | 2016-11-23 | 邻客音公司 | The memory cache of application layer management |
Non-Patent Citations (1)
| Title |
|---|
| Java智能卡内存调度机制研究与分析;鲁川等;《计算机应用与软件》;20130915(第09期);全文 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN109739779A (en) | 2019-05-10 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN108052396B (en) | Resource allocation method and system | |
| CN111124704B (en) | Data processing method, processor and terminal equipment | |
| CN109739779B (en) | Method for acquiring available storage space in java card, computer device and computer readable storage medium | |
| CN110022364B (en) | File downloading method and server | |
| EP3828696A1 (en) | Method invoke chain tracing method, electronic apparatus, and computer-readable storage medium | |
| CN113918232B (en) | Algorithm service calling method, device, server and storage medium | |
| CN110704202A (en) | Multimedia recording data sharing method and terminal equipment | |
| CN112214313A (en) | Memory allocation method and related equipment | |
| CN109348434B (en) | Scene information sending method, sending device and terminal equipment | |
| CN111796937A (en) | Resource allocation method based on memory, computer equipment and storage medium | |
| CN108509322B (en) | Method for avoiding excessive return visit, electronic device and computer readable storage medium | |
| CN112966094A (en) | Transaction data processing method, device and system | |
| CN101794310A (en) | Method, system and device for processing smart card database | |
| CN115002046A (en) | Message processing method, NUMA node, electronic device and storage medium | |
| CN113313594B (en) | Order processing method, order processing device, electronic equipment, storage medium and program product | |
| CN112650710B (en) | Data migration sending method and device, storage medium and electronic device | |
| CN111274017B (en) | Resource processing method and device, electronic equipment and storage medium | |
| CN110865848B (en) | Component interception method and terminal equipment | |
| CN112995982B (en) | Method, device, server and storage medium for scheduling cloud SIM card | |
| CN113746932B (en) | Network request merging method, device, electronic device and computer program product | |
| CN115952491A (en) | Method, device, electronic equipment and medium for hook target function | |
| CN111679909B (en) | Data processing method and device and terminal equipment | |
| CN111427550A (en) | Object creating method, terminal device and storage medium | |
| CN112035379B (en) | Method and device for using storage space, storage medium and electronic device | |
| CN113297149A (en) | Method and device for monitoring data processing request |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |