KR101474115B1 - Method of managing application data flow using singleton pattern - Google Patents

Abstract

A method of managing an Android application data flow using a singleton pattern is disclosed. The method includes the steps of: receiving a data store instruction of an activity of a database class; determining whether an instance for executing the data store instruction exists in the database class; if there is an instance for performing the data store instruction, Storing data using an instance for executing the data storage command, and creating a new instance for executing the data storage command when the instance for performing the data storage command does not exist, And storing the data.

Description

[0001] METHOD OF MANAGING APPLICATION DATA FLOW USING SINGLETON PATTERN [0002]

The following embodiments relate to a data flow management method for an application in an Android platform.

As smartphones become popular, more and more users are interested in developing their own applications. When developing an application, it is often necessary to transfer data that is common to many activities from one activity to another. In this case, the method of transmitting data using the intent class of Android is cumbersome and complicated because it has to perform repetitive work on the same data.

Embodiments of the present invention define data as a class using a singleton pattern. A singleton pattern is a pattern that guarantees that only one instance of a class is unique and provides a global point of contact where other classes can access it. When using the singleton pattern, efficient data management is possible because a large number of activities share data defined as a class.

A method of managing an Android application data flow using a singleton pattern according to an exemplary embodiment of the present invention includes: receiving a data store command of an activity of a database class; Determining whether an instance for executing the data storage command exists in the database class; Storing data by using an instance for executing the data storage command when there is an instance for performing the data storage command; And generating a new instance for executing the data save command when the instance for performing the data save command does not exist, and storing the data using the new instance.

The instance for executing the save command may be accessed by another class but can not be directly generated by the other class.

A method for managing an Android application data flow using a singleton pattern includes the steps of: when a plurality of threads simultaneously attempt to store data using an instance for executing the data store command, Processing the data so that the data can be stored using the instance; And storing the data by using the instance for executing the data storage command, and then processing another thread to store the data by using the instance for executing the data storage command .

The method may further include removing data stored in the database class at the end of an application configured with activities storing data in the database class.

The method of managing an Android application data flow using a singleton pattern may further include performing a part of data storage commands of the activity through an intent class.

The method of managing an Android application data flow using a singleton pattern may further include controlling a method of executing a data store command of the activity through a user interface.

A method for managing an Android application data flow using a singleton pattern according to an exemplary embodiment of the present invention includes: receiving a data load command of an activity of a database class; And loading data using an instance used when loading data corresponding to the data load command.

The instance for executing the load instruction may be accessed by another class but can not be directly generated by the other class.

A method for managing an Android application data flow using a singleton pattern includes: when a plurality of threads simultaneously attempt to load data using an instance for executing the data load command, only one of the threads executes the data load command Processing the data so that the data can be loaded using the instance; And after one of the threads loads the data using the instance for executing the data load instruction, the other thread loads the data using the instance for executing the data load instruction As shown in FIG.

The method for managing the Android application data flow using the singleton pattern may further include performing a part of the data load instruction of the activity through the intent class.

The method of managing an Android application data flow using a singleton pattern may further include controlling a method of performing a data load instruction of the activity through a user interface.

Embodiments of the present invention define data as a class using a singleton pattern. A singleton pattern is a pattern that guarantees that only one instance of a class is unique and provides a global point of contact where other classes can access it. When using the singleton pattern, efficient data management is possible because a large number of activities share data defined as a class.

1 is a diagram illustrating a process of transferring data between activities via an intent.
2 is a diagram showing a singleton pattern in UML.
FIG. 3 is a source code for generating a class using a singleton pattern in a database to be used in an Android application.
4 is a source code for storing and loading data in a database.
Figure 5 is source code that allows only one thread to create an instance if more than one thread intends to use the create method at the same time.
6 is a diagram illustrating that activities share data using a singleton pattern.
7 is a source code of a singleton class in which an object is instantly generated when a singleton class is loaded.
8 is a source code of a singleton class which is generated by a method call without generating an object when the singleton class is loaded.
FIG. 9 is a source code of a singleton class that combines the advantages of the source code in which an object is directly generated when a singleton class is loaded, and the source code generated by a method call without creating an object in a singleton class load.
10 is a source code of a singleton class in which an object is generated in an inner class.
11 is a flowchart showing a judgment process for maintaining a single instance.
12 is a block diagram of a system for managing an Android application data flow using a singleton pattern according to an embodiment of the present invention.

Hereinafter, embodiments will be described in detail with reference to the accompanying drawings.

As smartphones become popular, demand and supply of applications are increasing, and more users are interested in developing their own applications. Especially for Android smartphones, many developers are making their own applications because the information is vast, easy to find and free.

When developing an application, it is often necessary to transfer data from one activity to another activity, which is common to many activities. Developers with little or no experience in development are experiencing inconvenience in managing data flow in these areas.

The present invention manages data in a single class using a Singleton pattern, which is one of the design patterns, so that developers can easily manage data flow, so that data that can be easily generated and modified in any activity Management techniques are presented.

An activity is an active screen used by a user, and several activities form an application. Data passing between activities on Android is performed through the Intent class.

1 is a diagram illustrating a process of transferring data between activities via an intent.

Referring to FIG. 1, an intent for passing an activity from a activity to a sub-activity is generated (110), and a sub-activity is called (120) using a startActivityForResult method to deliver an intent including a corresponding parameter. Then, the subentity calls the intent 130 to store the data, and then returns the intent 140 using the setResult method. After receiving the data through the intent using the onActivityResult method, the activity is performed (150).

A singleton pattern is a pattern that guarantees that only one instance of a class is unique and provides a global point of contact that can access this instance.

2 is a diagram showing a singleton pattern in UML.

Referring to FIG. 2, a Singleton instance is first declared as a private static, so that it can not be accessed from the outside, and instances added to the static are not duplicated. Then declare the constructor private, making it impossible to create an instance using new in another class. However, if you do this, you will not be able to use it yourself, so you will create a getInstance () method that will be public static and accessible from anywhere, returning a new instance if the instance is null and an existing instance if it is not null. do.

When managing the flow of data that is commonly used by multiple activities, passing data using the Android intent class has a somewhat cumbersome and complicated procedure because it must continue to iterate over the same data. Defining data in a class using a singleton pattern allows the same data to be retrieved and modified in any activity class.

The advantages obtained by applying the singleton pattern are as follows. Since it is static first, it is allocated to the stack area, it is removed at the end of the program, and even if the instance is not declared, the memory is already allocated to the static memory.

FIG. 3 is a source code for generating a class using a singleton pattern in a database to be used in an Android application.

Referring to FIG. 3, a database used in an Android application is generated as a class by applying a singleton pattern. I created an instance of the Database class private static and declared the constructor private so that I could not instantiate it directly from another class. The constructor contains the methods that should be run when this class is called. And if you have a global method to create an instance of this class, and you do not have an instance, then if you call the constructor, it will return the existing instance.

4 is a source code for storing and loading data in a database.

Referring to FIG. 4, data in a database may be generated in another class, and the generated data may be used in another class. A class called LoadingActivity actually creates a database while loading the program (410). A class called PredictiveMessageApp receives data using the generated database (420).

It is simpler and more convenient to create a class and use it in all parts, as opposed to creating an intent each time to pass data between activities.

On the other hand, if we use a lot of singleton patterns referring to several places globally, the program complexity increases as the global variable increases. When two threads access simultaneously, they create two objects, one of which is discarded, which is not suitable for multithreaded environments.

Applying a singleton pattern is disadvantageous in terms of memory and program complexity when data generated from each activity needs to be delivered. It can be used in combination with the data management method using the above-mentioned intent by grasping the advantages and disadvantages of the application of the singleton pattern and the application in a certain situation. When the data management using the singleton pattern is mixed with the data management using the intent, it is possible to determine which method to use according to preset conditions, or to directly set a method to use the user interface through the user interface.

Figure 5 is source code that allows only one thread to create an instance if more than one thread intends to use the create method at the same time.

Referring to FIG. 5, in case of using in a thread environment, since synchronization is required, a method which can acquire an object using synchorinized is declared.

6 is a diagram illustrating that activities share data using a singleton pattern.

Referring to FIG. 6, it can be seen that the MainActivity 610 and the SubActivity 620 share data by storing and loading data in the Singleton 630, respectively.

7 is a source code of a singleton class in which an object is instantly generated when a singleton class is loaded.

Referring to FIG. 7, when an activity loads a singleton class, the object is immediately generated.

8 is a source code of a singleton class which is generated by a method call without generating an object when the singleton class is loaded.

Referring to FIG. 8, an object is not generated immediately when an activity loads a singleton class, but is coded so that an object is generated when a method is called.

FIG. 9 is a source code of a singleton class that combines the advantages of the source code in which an object is directly generated when a singleton class is loaded, and the source code generated by a method call without creating an object in a singleton class load.

Referring to FIG. 9, the source code in which an object is directly generated during singleton class loading and the source code generated by a method call without coding an object in singleton class loading are combined and coded.

10 is a source code of a singleton class in which an object is generated in an inner class.

Referring to FIG. 10, a SingletonHolder class is declared in the Singleton class and the object class is generated in the inner class.

11 is a flowchart showing a judgment process for maintaining a single instance.

Referring to FIG. 11, a method for managing an Android application data flow using a singleton pattern according to the present invention receives a data store command (1110).

The step 1110 of receiving the data store command by the database class is a step in which the database class receives the command transmitted by the activity to store the data. When a singleton class is loaded, an instance is instantly created, or even if a singleton class is loaded, the instance is not created immediately but can be generated as a separate call.

The Android application data flow management method using the singleton pattern of the present invention determines whether there is an instance for storing data (1120).

Step 1120 of determining whether there is an instance for storing data may be a step of determining whether an instance of the database class has been created at the time of singleton class loading or by a separate call. It is possible to judge whether the instance corresponds to null and to perform this judgment process.

An instance of a singleton class is an instance that can be accessed by another class, but not directly through another class.

In the method of managing an Android application data flow using a singleton pattern according to the present invention, when it is determined that an instance exists, data is stored using an instance (1130).

If it is determined that the instance exists, the step 1130 of storing the data using the instance may be a step of storing the data using the previously created instance. When an instance of a database class is already created at load time of a singleton class or by a separate call, this instance is used to store data.

In the method of managing an Android application data flow using a singleton pattern according to the present invention, if it is determined that an instance does not exist, a new instance is created (1140), and data is stored using the instance (1130).

If it is determined that the instance does not exist, a step 1130 of creating a new instance (1140) and storing the data using the instance may be a step of creating a new instance and storing the data. When an instance of a database class is not created at singleton class loading or by a separate call, a new instance is created and data is stored using this instance.

When an activity loads data, it can be used to load data using the instance used to store the data. A single instance retention can be realized by this method. The data management method using the instance at the time of data loading can be applied to the data management method at the time of storing the data, so that a detailed description will be omitted.

12 is a block diagram of a system for managing an Android application data flow using a singleton pattern according to an embodiment of the present invention.

12, the system is implemented through an Android terminal 1200. The Android terminal 1200 includes a display unit 1210, a processing unit 1220, an input unit 1230, a storage unit 1240, and a communication unit 1250 .

The display unit 1210 may include a display panel having various types and sizes, and provides a user interface for the user at the Android terminal 1200. [ In the display unit 910, information necessary for application data flow management can be provided in various environments.

The processing unit 1220 may include various processors that process the operations required for the practice of the present invention. The processing unit 920 processes operations and data necessary for application data flow management.

The input unit 1230 may include various devices for the user of the application to input data or to control the user interface. An input device such as a keyboard, a mouse, a touch pad, and a digital pen may be included.

The storage unit 1240 may include a magnetic recording medium such as a hard disk, an optical recording medium such as a CD-ROM and a DVD, and a storage such as a ROM, a RAM, and a flash memory. Various classes, methods, and applications of the Android platform are stored.

The communication unit 1250 includes LAN / WAN, wired / wireless, RFID, NFC, and the like for communication between a computer and a smart device, and can perform data transmission, reception, and update.

The contents described with reference to Figs. 1 to 11 can be directly applied to each unit shown in Fig. 12, so that a detailed description of Fig. 15 is omitted.

The method according to an embodiment may be implemented in the form of a program command that can be executed through various computer means and recorded in a computer-readable medium. The computer-readable medium may include program instructions, data files, data structures, and the like, alone or in combination. The program instructions to be recorded on the medium may be those specially designed and configured for the embodiments or may be available to those skilled in the art of computer software. Examples of computer-readable media include magnetic media such as hard disks, floppy disks and magnetic tape; optical media such as CD-ROMs and DVDs; magnetic media such as floppy disks; Magneto-optical media, and hardware devices specifically configured to store and execute program instructions such as ROM, RAM, flash memory, and the like. Examples of program instructions include machine language code such as those produced by a compiler, as well as high-level language code that can be executed by a computer using an interpreter or the like. The hardware devices described above may be configured to operate as one or more software modules to perform the operations of the embodiments, and vice versa.

While the present invention has been particularly shown and described with reference to exemplary embodiments thereof, it is to be understood that the invention is not limited to the disclosed exemplary embodiments. For example, it is to be understood that the techniques described may be performed in a different order than the described methods, and / or that components of the described systems, structures, devices, circuits, Lt; / RTI > or equivalents, even if it is replaced or replaced.

Therefore, other implementations, other embodiments, and equivalents to the claims are also within the scope of the following claims.

Claims (11)

Receiving a data storage instruction of an activity of a database class executed in the processing unit;
Determining whether an instance for executing the data storage command exists in the database class;
Storing the data using the instance for performing the data storage command when the processing unit has an instance for performing the data storage command; And
Generating a new instance for executing the data storage command and storing data using the new instance when the processing unit does not exist;
Wherein the instance for performing the data save command is accessible by another class but is not directly generated by the other class.
The method according to claim 1,
Wherein the step of storing the data using the instance for performing the data storage command includes the steps of:
In a case where a plurality of threads simultaneously attempt to store data using an instance for executing the data storage command, the processing unit may allow only one thread to store data using an instance for executing the data storage command A method for managing an Android application data flow using a singleton pattern processing.
3. The method of claim 2,
Wherein the processing unit stores data by using one of the threads for executing the data storage command and then processes the data so that another thread can store data using the instance for executing the data storage command Wherein the method further comprises the steps of:
The method according to claim 1,
Storing the data using the instance for performing the data storage command when the processing unit has an instance for performing the data storage command; And
Wherein when the processing unit does not have an instance for executing the data storage command, the processing unit creates a new instance for executing the data storage command, and stores the data using the new instance,
Further comprising the step of, when the application configured with the activities storing data in the database class is terminated, the processing unit removing data stored in the database class.
The method according to claim 1,
Storing the data using the instance for performing the data storage command when the processing unit has an instance for performing the data storage command; And
Wherein the processing unit generates a new instance for executing the data storage command when the instance for performing the data storage command does not exist and storing the data using the new instance
And the processing unit performs a part of data storage commands of the activity through an intent class.
6. The method of claim 5,
Wherein the processing unit controls a method of executing a data storage command of the activity through a user interface.
Receiving a data load instruction of an activity of a database class executed in the processing unit; And
And loading the data using the instance that the processing unit used when storing the data corresponding to the data load command,
Wherein the instance for performing the data load command is accessible by another class but is not directly generated by the other class.
8. The method of claim 7,
Wherein the step of loading data by using the instance used when the processing unit stores the data corresponding to the data load command
In a case where a plurality of threads simultaneously attempt to store data using an instance for executing the data storage command, the processing unit may allow only one thread to store data using an instance for executing the data storage command A method for managing an Android application data flow using a singleton pattern processing.
9. The method of claim 8,
Wherein the processing unit stores data by using one of the threads for executing the data storage command and then processes the data so that another thread can store data using the instance for executing the data storage command Wherein the method further comprises the steps of:
8. The method of claim 7,
Wherein the step of loading data by using the instance used when the processing unit stores the data corresponding to the data load command
And the processing unit performs a part of data storage commands of the activity through an intent class.
11. The method of claim 10,
Wherein the processing unit controls a method of executing a data storage command of the activity through a user interface.

Images