Patent ID: 12243018

DETAILED DESCRIPTION

Description of the present disclosure is only an embodiment for structural or functional description, and therefore the scope of the present disclosure should not be construed as limited to embodiments described in the text. That is, since the embodiments may be variously modified and may have various forms, the scope of the present disclosure should be construed as including equivalents capable of realizing the technical idea. In addition, a specific embodiment is not construed as including all the objects or effects presented in the present disclosure or only the effects, and therefore the scope of the present disclosure should not be understood as being limited thereto.

On the other hand, the meaning of the terms described in the present application should be understood as follows.

Terms such as “first” and “second” are intended to identify one component from another component, and the scope of the present disclosure should not be limited by these terms. For example, a first component may be named a second component and the second component may also be similarly named the first component.

It is to be understood that when one element is referred to as being “connected to” another element, it may be connected directly to or coupled directly to another element or be connected to another element, having the other element intervening therebetween. On the other hand, it is to be understood that when one element is referred to as being “connected directly to” another element, it may be connected to or coupled to another element without the other element intervening therebetween. Meanwhile, other expressions describing a relationship between components, that is, “between”, “directly between”, “neighboring to”, “directly neighboring to” and the like, should be similarly interpreted.

It should be understood that the singular expression include the plural expression unless the context clearly indicates otherwise, and it will be further understood that the terms “comprises” or “have” used in this specification, specify the presence of stated features, steps, operations, components, parts, or a combination thereof, but do not preclude the presence or addition of one or more other features, numerals, steps, operations, components, parts, or a combination thereof.

In each step, an identification code (for example, a, b, c, and the like) is used for convenience of description, and the identification code does not describe the order of each step, and each step may be different from the specified order unless the context clearly indicates a particular order. That is, the respective steps may be performed in the same sequence as the described sequence, be performed at substantially the same time, or be performed in an opposite sequence to the described sequence.

The present disclosure can be embodied as computer readable code on a computer readable recording medium, and the computer readable recording medium includes all types of recording devices in which data can be read by a computer system. Examples of the computer readable recording medium may include a read only memory (ROM), a random access memory (RAM), a compact disk read only memory (CD-ROM), a magnetic tape, a floppy disk, an optical data storage, or the like. In addition, the computer readable recording medium may be distributed in computer systems connected to each other via a network, such that the computer readable codes may be stored in a distributed scheme and executed.

Unless defined otherwise, all the terms used herein including technical and scientific terms have the same meaning as meanings generally understood by those skilled in the art to which the present disclosure pertains. It should be understood that the terms defined by the dictionary are identical with the meanings within the context of the related art, and they should not be ideally or excessively formally defined unless the context clearly dictates otherwise.

FIG.1is a diagram illustrating a system100of processing a dialog based message object according to an embodiment of the present invention.

Referring toFIG.1, a system100of processing a dialog based message object includes an apparatus110of processing a dialog based message object and a user terminal120.

The apparatus110of processing a dialog based message object corresponds to a computing device that can be connected to the user terminal120via a network. In one embodiment, the apparatus110of processing a dialog based message object may manage a group of participating members via the user terminal120.

In one embodiment, the apparatus110of processing a dialog based message object may manage the user terminal120of the group of the members through an agent installed in the user terminal120. Here, the agent may correspond to computer software that can be installed on the user terminal120and connect the user terminal120to the apparatus110of processing a dialog based message under the approval of the user terminal120to process the dialog based message object.

The user terminal120may correspond to a computing apparatus that may be connected to the apparatus110of processing a dialog based message object via a network, and may be used by a user who participates in a dialog. For example, the user terminal120may be implemented as a desktop, a laptop, a tablet PC or a smartphone.

FIG.2is a block diagram of the apparatus110of processing a dialog based message object110inFIG.1.

Referring toFIG.2, the apparatus110of processing a dialog based message object may include a processor210, a memory220, a user input and output unit230, and a network input and output unit240.

The processor210may control overall operations of the apparatus110of processing a dialog based object, and may be electrically connected to the memory220, the user input and output unit230, and the network input and output unit240to control a data flow therebetween.

In one embodiment, the processor210may execute a dialog based message object processing procedure, and may read a message object from the memory220or write the message object in the memory220during this execution.

More detailed operations of the processor210will be described with reference toFIG.3.

The memory220may store data used to process the dialog based message object processing procedure. In one embodiment, the memory220may be implemented as a nonvolatile memory such as a solid state disk (SSD) or a hard disk drive (HDD). In another embodiment, the memory220may be implemented as a volatile memory such as random access memory (RAM).

The user input and output unit230may be used to input a message object in the dialog and may be implemented as a mouse, a trackball, a touch pad, a graphic tablet, a scanner, a touch screen, a keyboard, or a pointing device. The user input and output unit230may be used to represent the message object in the dialog and can be implemented as a monitor or a touch screen.

The network input and output unit240may correspond to a hardware device that supports data communication with the user terminal120. For example, the network input and output unit240may include an adapter for local area network (LAN) communication.

FIG.3is a block diagram illustrating functional elements of the processor inFIG.2.

Referring toFIG.3, from a functional point of view, the processor210may include a dialog processor310, a message object processor320, an unread message processor330, a task object processor340, a task content reminder350, a dialog badge processor360, a controller370.

The dialog processor310may create a dialog in which at least one user participates. Here, each of the at least one user can access the dialog via the user terminal120. The dialog processor310provides a dialog with a message thread that contains, in times series, the existing message objects that are spontaneously created by at least one user. The dialog may correspond to a meeting space on cyber in which at least one user participates, and the message thread may be substantiated in the dialog as a set of message objects connected in time series that are provided by the at least one user. In one embodiment, the dialog processor310may provide a dialog through a display module in the user terminal120and provide the message thread through the dialog.

The message object processor320may process message objects transmitted and received between users participating in the dialog. Here, the message object is an entity including a message created by a user, and the message does not necessarily mean text, but may include a complex entity composed of at least one of texts, voice, photos, videos, or task objects. The message object processor320may receive an unspecified or specified message object from one of the at least one user and additionally insert the received unspecified or specified message object to the message thread. The unspecified message object may include a message object that does not specify a specific user, and the specified message object may include a message object that specifies a specific user. For example, when the message object processor320allows [user A] to specify [user B] to transmit a message object containing the message “Please perform task evaluation” through a dialog, the message object processor320may add an object to the message thread and allow the [user B] to identify the specified message object. According to an embodiment, when the specified message object is received, the message object processor320may notify the specified user of the arrival of the message object in real time.

The unread message processor330detects whether the specified user has read the specified message object in the message thread, and counts the number of unread specified message objects. The message thread may include five specified message objects that specify the [user A] and three specified message objects that specify the [user B]. For example, it may be assumed that the [user A] reads one of five specified message objects and two of three specified message objects that specifies the [user B]. In addition, it may be assumed that the [User B] reads two of five specified message objects that specifies the [User A] and reads one of three specified message objects that specifies the [User B]. The unread message processor330may count the number of unread specified message objects as four from the viewpoint of the [user A], and count the number of unread specified message objects as two from the viewpoint of the [user B]. The unread message processor330may provide the specified user with the number of unread specified message objects. For example, the unread message processor330may provide the [user A] with the number of unread specified message objects as four, and provide the [user B] with the number of unread specified message objects as two. That is, the unread message processor330may provide each specified user with the number of unread specified message objects that is not read by each specified user.

In addition, the unread message processor330may calculate the number of unread unspecified message objects, which are not read by at least one user (that is, all users participating in the dialog), in the message thread. The message thread may include five specified message objects and three unspecified message objects that specify the [user A]. For example, when the [user A] reads one of five specified message objects and one of three unspecified message objects, the unread message processor330may provide the [user A] with the number of unread specified message objects as four and the number of unread unspecified message objects as two from the viewpoint of the [user A]. That is, the unread message processor330may calculate the number of unread specified message objects and the number of unspecified message objects, respectively, and provide the calculated number of specified message objects and unspecified message objects to the corresponding user.

In addition, the unread message processor330may count the number of unread unspecified message objects and the number of unread specified message objects for at least one user based on whether a corresponding user reads message objects of a message thread. At this point, the specified message object may be counted as a specified message object for a specified user and may be counted as an unspecified message object for a user other than the specified user among at least one user.

For example, when a message thread contains five specified message objects specifying the [User A], three specified message objects specifying the [User B], and four unspecified message objects specifying no one, the unread message processor330may count the number of specified message objects as five and the number of unspecified message objects as seven from the viewpoint of the [User A]. In addition, the unread message processor330may count the number of specified message objects as three and the number of unspecified message objects as nine from the viewpoint of the [User B].

At this point, the five specified message objects that specifies the [User A] may correspond to unspecified message objects from the viewpoint of the [User B], and the three specified message objects that specifies the [User B] may correspond to unspecified message objects from the viewpoint of the [User A]. Therefore, when the [User A] reads one of the five specified message objects specifying the [User A], two of the three specified message objects specifying the [User B], and one of the four unspecified message objects specifying no one, respectively, the unread message processor330may count the number of unread unspecified message objects as 4 and the number of unread specified message objects as 4 from the viewpoint of [User A]. In addition, when the [User B] reads two of the five specified message objects specifying the [User A], one of the three specified message objects specifying the [User B], and two of the four unspecified message objects specifying no one, respectively, the unread message processor330may count the number of unread unspecified message objects as five and the number of unread specified message objects as two from the viewpoint of [User B].

The unread message processor330may provide the number of users who does not read the unspecified message object in the message thread. The message thread may contain two unspecified message objects, and the number of users (that is, dialog participants) participating in the dialog may correspond to 10. For example, when four of ten dialog participants read a first unspecified message object, the unread message processor330may provide the number of users who does not read the first unspecified message object as six, and when two of ten dialog participants read a second unspecified message object, the unread message processor330may provide the number of users who does not read the second unspecified message object as eight. That is, the unread message processor330may calculate and provide the number of users who does not read each unspecified message object.

Meanwhile, the unread message processor330may perform processing for reading the specified message object and the unspecified message object as follows.

When the specified message object is read, the unread message processor330may allow the corresponding user to read the corresponding specified message object by providing a user reaction (user input such as click or touch) to the corresponding specified message object. That is, when the user reaction of the corresponding user is input to the specified message object, the unread message processor330may process the specified message object as read and may subtract the number of unread specified message objects.

When the unspecified message object is read, the unread message processor330can assume that the user has read the unspecified message objects in the message thread if any user participates in the dialog. That is, the unread message processor330may process the unspecified message object as read regardless of the user response and may subtract the number of unspecified message objects that is not read.

As a result, as described above, the unread message processor330may count and calculate the number of unspecified message objects and the number of specified message objects, respectively, in different ways. However, unlike what has been described above, the unread message processor330may apply opposite methods to a specified message objects and an unspecified message objects and may apply the same method to both the specified message objects and the unspecified message objects. That is, the unread message processor330may individually process reading of unspecified or specified message objects according to a user reaction (a user input such as click or touch) and may integratedly process reading of unspecified or specified message objects in a corresponding message thread according to a user's dialog participation. Meanwhile, the user's dialog participation may include a case of activating a dialog in which the user is already participating, such as executing a program.

The task object processor340may add, as a specified message object, a task object for a user to instruct a specific user to process a task to a message thread, and process the task object among the specified message object. Here, the task object corresponds to an independent message object used for processing a task in a dialog, and may include a task creator, a task handler, a task deadline, a task content, and a task state. The task creator may correspond to a task instructor capable of creating the task object, and the task handler may correspond to a task performer specified by the task creator. The task deadline may correspond to the deadline of the task specified by the task creator, and may be changed according to a spontaneous change of the task creator or a change request of the task handler, if necessary. The task content may include a simple text or a separate document that may be directed by the task creator. The task state is updated by the task creator or the task handler as the progress state of the task, and may correspond to an unconfirmed state, a pre-progress state, a progressing state, a post-progress state, an evaluation state, a completed state, or an overdue state.

The task object processor340detects whether the specified message object in the message thread corresponds to the task object. In one embodiment, the task object processor340may extract the task object from the message thread according to the request of the task handler and provide the extracted task object to the dialog.

The task object processor340may process the task object through the specified message processor. The specified message processor may refer to a process performed in the background, and may be performed by the task creator or the task handler or may be performed according to a specific event (for example: alarm according to a task schedule). The task object processor340may update a task state according to a predefined task processing flow through the specified message processor, and change the specified user according to the updated task state.

For example, the specified message processor may detect that [task handler B] receives <task object P> to set the task state to [unconfirmed state], and may detect that [task handler B] confirms <task object P> to change [unconfirmed state] to [pre-progress state]. The specified message processor may detect that [task handler B] proceeds to <task object P> to change [pre-progress state] to [progressing state], and detect that [task handler B] completes <task object P> to change the [progressing state] to [post-progress state] and change the specified user from [to-do handler B] to [to-do creator A]. The specified message processor may detect that the [to-do creator A] evaluates the <task object P> to change the [post-progress state] to [completed state].

The task object processor340may predict (before the task deadline passes) or detect (after the task deadline passes) that the [task handler B] passes the task deadline of the <task object P> to create a task deadline event as a specific event. For example, the specified message processor may receive the task deadline event and notify the [task handler B] of the task deadline to induce rapid task processing of the [task handler B] on the <task object P>. When the task object processor340receives the completed state from [task handler B], the task object processor340requests the [task creator A] to evaluate the task content as the specified message and changes the task state to the evaluation state. The task object processor340may change the specified user from the [to-do handler B] to the [to-do creator A] when the task state is changed to the evaluation state, and allow the [task creator A] to record the task evaluation in the <task object P>. In addition, the task object processor340may track the task state of the <task object P> and finally receive the evaluation on the <task object P> as a task rating from the [task creator A].

The task content reminder350may create the task deadline event as a specific event according to the task deadline in the task object. In one embodiment, the task content reminder350may periodically check the task deadline in the task object, and may create the task deadline event when the task deadline is imminent. The task content reminder350may define the imminence of the task deadline according to a user's setting, and for example, may set the imminence of the task deadline to one week before the task deadline by default.

The task content reminder350may wake up the specified message processor through the task deadline event, and the specified message processor may remind the task handler of the task content.

The task content reminder350may create a remind message during the reminder process. Here, the remind message may correspond to a specified message object specifying a user, and may be transmitted to the task handler at the time of reminding when the task handler is changed according to the task state of the task object. For example, when the task handler of the <task object P> is changed from the [task handler A] to the [task handler B], the task content reminder350may transmit the remind message as the specified message object to the [task handler B]. In addition, the task content reminder350may transmit to the [task handler B] the task content of the <task object P> with the remind message as the specified message object.

The task content reminder350may provide the task handler with the task creator, at least a portion of the task content, and the task deadline through the remind message.

The task content reminder350may detect an overdue of the task deadline and may continuously provide the task handler with the task content with a push notification when the task deadline passes. In one embodiment, the task content reminder350may provide the push notification regardless of the connection of the dialog by the task handler.

The dialog badge processor360may provide the specified user with the number of unread message objects for the specified message object in the message thread as the badge of the dialog. Here, as illustrated inFIG.5, the badge of the dialog may be implemented as an icon545in the dialog list before users participate in the dialog, and an icon545may include the number of unread message objects.

In addition, the dialog badge processor360may provide the number of specified message objects and the number of unspecified message objects for the specified user in the message thread at the same time as the badge of the dialog. The message thread may include five specified message objects and three unspecified message objects that specify [user A]. For example, when the [user A] has read one of the five specified message objects and one of the three unspecified message objects, the dialog badge processor360may provide the [user A] with the number of unread specified message objects as four and the number of unread unspecified message objects as two, respectively, as the badge of the dialog. That is, the dialog badge processor360may calculate the number of unread specified message objects and the number of unread unspecified message objects, respectively, for the corresponding user, and simultaneously provide as the badge of the dialog the number of unread specified message objects and unread unspecified message objects calculated.

The dialog badge processor360may provide as the badge of the dialog the number of its own unread specified message objects for the specified message object in the message thread, and provide as the badge of the dialog the number of unread specified message objects specifying the user to allow the specified user to more easily check the existence of the unread specified message object.

For example, it is assumed that the number of dialog participants is five, the number of specified message objects is ten, the number of specified message objects specifying the [specified user A] is three, and the number of specified message objects specifying the [specified user B] is five. When the [specified user A] has read two specified message objects, the dialog badge processor360can provide the number of its own unread message objects in the dialog layout as one.

The dialog badge processor360may provide the specified user with the number of unread message objects for the specified message object in the message thread and the number of unread message objects that the user does not read as the badge of the dialog.

The controller370may control the overall operation of the processor210, and manage the control flow or the data flow between the dialog processor310, the message object processor320, the unread message processor330, the task object processor340, the task content reminder350, and the dialog badge processor360.

FIG.4is a flowchart illustrating a process performed in the apparatus of processing a dialog based message object ofFIG.1.

InFIG.4, the apparatus110of processing a dialog based message object may create a dialog participating by at least one user through the dialog processor310(step S410). For example, the dialog processor310may create [dialog X] in which the [user A] and the [user B] participate.

The dialog processor310may provide the dialog with a message thread including the existing message object spontaneously created by at least one user in time series (step S430). For example, the dialogue processor310may add [message object M] created by the [user A] to the message thread of the [dialog X] in which the [user A] participates in time series.

The message object processor320may receive an unspecified or specified message object from one of the at least one user and additionally insert the received unspecified or specified message object into the message thread (step S450).

For example, the message object processor320may additionally insert the [specified message object M] received from the [user A] into the message thread of the [dialog X].

The unread message processor330may count the number of unread unspecified message objects and the number of unread specified message objects for each of at least one user based on whether the user reads the message objects in the message thread (step S470). For example, the message thread of the [dialog X] may include the [specified message object M] which specifies the [specified user A], the unread message processor330may detect whether the [specified user A] provides the user reaction (user input such as a click or a touch) to the [specified message object M], and if detected, it may be determined that the [specified user A] has read the [specified message object M]. When the [specified message object M] is read, the unread message processor330may subtract one from the number of unread specified message objects.

When an access of at least one user to the dialog is detected through the unread message processor330, the apparatus110of processing a dialog based message object may provide a corresponding user with the number of unread unspecified message objects and the number of unread specified message objects (step S490). That is, when the access of at least one user to the dialog is detected or the connection of a corresponding user is sensed, the message processor330may provide a specified user connection event to the specified message processor to notify the existence of an unread unspecified message object or an unread specified message object in the dialog, and may provide the corresponding user with the number of unread unspecified message objects or the number of unread specified message objects.

For example, assuming that [Dialog X] contains five specified message objects and three unspecified message objects, which specify [Specified User A], and [Specified User A] reads only one specified message object, the unread message processor330may provide the number of unread specified message objects as four and the number of unread unspecified message objects as three to [Specified User A].

FIG.5is a diagram illustrating a dialog list user interface generated by the apparatus of processing a dialog based message object ofFIG.1.

Referring toFIG.5, a dialog list user interface500includes a task organization control510, a project control520, a badge control525, a user control530, a dialog list control540, and a dialog550.

The task organization control510is a user interface representing a task organization within a company, and may be used when accessing a task organization to which users belong through a user input or when managing the task organization managed by the users. For example, the task organization control510may be used to access a management support office within a company.

The project control520is a user interface that summarizes a task flows for all tasks included in the project being performed by the task organization selected through task organization control510. The task flow represents a plan-do-check-act (PDCA) process, and includes a PLAN process, a DO process, a CHECK process, and an ACT process, each of which has the badge control525including a badge for a message object arranged therearound.

The PLAN process includes a step of establishing a feasible plan by clarifying goals or policies, the DO process includes a step of measuring a progress of the plan as the plan is executed according to the plan, and the CHECK process includes a step of evaluating an achievement and manner of performance to review success or failure factors, and the ACT process includes a step of feed backing to a next plan through improvements and corrections.

The badge control525represents the number of unread specified message objects and the number of unread unspecified message objects, respectively, for the entire dialogs550a-550c, and can be used to access the corresponding message object through the user input. In one embodiment, the badge control525may be updated as the number of unread specified and unspecified message objects increases or decreases. For example, the badge control525may highlight and display the number of unread specified message objects in red. In one embodiment, the badge control525may receive a user input (for example, click or touch) for each of the number of unread specified message objects and the number of unread unspecified message objects, and may provide the corresponding unread message object through a separate user interface.

The user control530represents a user who has accessed the dialog list user interface500and can change to another user through the user reaction (for example, click or touch).

The dialog list control540corresponds to a user interface that lists the dialogs550in order and allows access to a particular dialog550athrough the user input. In one embodiment, the dialog list control540may arrange the dialogs550in the order of the dialog550in which the most recent conversation takes place. In another embodiment, the dialog list control540may arrange the dialogs550in the order of the dialogs550including the specified message object for the most recently generated specified user.

The badge control545may provide the number of unread specified message objects and the number of unread specified message objects for each of the dialogs550shown through the dialog list control540. For example, for the specified user A of the user control530, the badge control525may provide the number [9 (red)] of unread specified message objects and the number [10] of unread unspecified message objects in the dialog550a. In one embodiment, the badge control545may receive the user input (for example, click or touch) for each of the number of unread specified message objects and the number of unread unspecified message objects, and may provide the corresponding unread message object through a separate user interface.

InFIG.5, the dialog list user interface500may receive the user input (for example, touch) for the dialog550ain the dialog list control540, and the contents thereof will be described with reference toFIG.6.

FIG.6is a diagram illustrating a process of processing a task object created by the apparatus of processing a dialog based message object ofFIG.1.

The dialog task interface600ofFIG.6may be accessed through the dialog550, and the contents of the dialog list user interface500ofFIG.5will be omitted.

Referring toFIG.6, the dialog task interface600includes a project task control610, a task schedule control620, and a message thread control630.

The project task control610can be used to control a description, a schedule, and dialog attendance of a project associated with the dialog540. Here, the project description includes brief contents prepared by an administrator for the project, the schedule includes a task schedule of the project, and the dialog participant may be used to know users who are participating in the project.

The task schedule control620may provide progress states of the task objects to be used to control the task objects for each progress state. The progress states of the task objects may be divided into scheduled (that is, including unconfirmed state and pre-progress state), ongoing (that is, including progressing state and post-progress state), past (that is, overdue state), and confirmed (completed state and evaluation state), each of which may represent the number of task objects.

The message thread control630may provide a message thread composed of the message objects created in the dialog540in time series and may be used for a user to control a specific message object through the user input (for example, click or touch). For example, when the message object corresponds to the unspecified message object, the message thread control630may request a user who transmits the corresponding unspecified message object through the user input to prepare the specified message object. In another example, the message thread control630detects that the user is a specified user when the message object corresponds to the specified message object, and if so, the message thread control630may process that the corresponding message object (for example, a task object) is checked, and if not, the message thread control630may request the user to prepare the specified message object in the same manner as the unspecified message object.

InFIG.6, the dialog task interface600may receive the user input (for example, click or touch) for the task schedule625in the task schedule control620to more specifically indicate the progress states of the task objects. The contents thereof will be described with reference toFIG.7.

FIG.7is a diagram for describing task objects for each task state created by the apparatus of processing a dialog based message object ofFIG.1.

A task object interface700for each task state ofFIG.7may be accessed through the task schedule control620, and the contents of the dialog list user interface500and the dialog task interface600ofFIGS.5and6will be omitted.

Referring toFIG.7, the task object interface700for each task state includes a task progress control710and a task object control730.

InFIG.7, the task object interface700for each task state represents task objects for each task state, and may be generated to provide a task object given to the specified user for each task state to help the task convenience of the specified user.

The task progress control710classifies task objects for each task state and may include, for example, scheduled, ongoing, past, and confirmed.

The task progress control710may be provided to visually identify the number of unread specified message objects and the number of unread unspecified message objects around the task state (for example, scheduled, ongoing, past, and confirmed), and receive the user input (for example, click or touch) to separately provide the corresponding message object. For example, when the number [2] of unread specified message objects in the task state [ongoing] is selected through the user input, the task progress control710may provide two unread specified message objects to a separate user interface or the user interface at the bottom of the corresponding task state.

The task object control730may be aligned with the identified task state at the bottom of the task progress control710. The task object control730may summarize an indicator731indicating whether a task deadline approaches or passes, an indicator733indicating a task creator, and an indicator735indicating a task deadline. For example, the task object control730may receive the user input and provide the task object to a separate user interface in detail.

FIG.8is a diagram for describing message transmission performed in the apparatus of processing a dialog based message object ofFIG.1.

Referring toFIG.8, a message transmission interface800includes a user-specified control810, a message editing control820, and a message transmission control830.

The user-specified control810may be used to specify a specified user, and may provide as a list a dialog participant participating in a current dialog to receive an instruction (for example, special character [@]) to specify the specified user through a message object creator (for example, user A) so that it can be selected by the message object creator. In one embodiment, the user-specified control810may designate a plurality of specified users by sequentially inputting the special character [@ ].

The message editing control820may receive a message object as text characters or as specific objects (for example, a picture object, a video object, a document object, and a task object), and transmit the message object to the corresponding user through the message transmission control830.

FIGS.9A and9Bare diagrams for describing an embodiment of an operation of processing a dialog based message object according to the present disclosure.

Referring toFIGS.9A and9B, the apparatus110of processing a dialog based message object may create a dialog, in which at least one user participates, and provide through the dialog a message thread that contains, in time series, existing message objects950. In addition, the apparatus110of processing a dialog based message object may receive an unspecified message object or a specified message object and additionally insert the unspecified message object or the specified message object into the message thread.

In this case, the specified message object may correspond to a message object specified by a specific user, and a special character [@] may be used as a command for specifying User A or User B inFIG.9A. For example, a message object containing “@User A” may be counted as a specified message object for User A, and a message object containing “@User B” may be counted as a specified message object for User B. In the case ofFIG.9A, the number of specified message objects for the User A may correspond to two, and the number of specified message objects for the User B may correspond to three. In this case, when the corresponding specified message objects are not read by the User A and the User B, the number910of unread specified message objects may correspond to two and three, respectively.

In addition, an unspecified message object may correspond to a message object that does not specify a specific user, and even a message object with a specified user may correspond to an unspecified message object for a user other than the specified user. For example, a specified message object that specifies the User B inFIG.9Amay be counted as an unspecified message object for the User A. Therefore, the number of unspecified message objects for the User A may be counted as six in total by adding three, which is the number of message objects not specifying a specific user, and three, which is the number of specified message objects specifying the User B. In this case, when the corresponding unspecified message objects are not read by the User A, the number930of unread unspecified message objects may correspond to six.

InFIG.9B, the User A may click or touch message objects950in the dialog to read detailed contents of the corresponding message object950, and when the corresponding user reaction is input, the unread message processor330may process unspecified message objects or specified message objects as read. That is, the unread message processor330may decrease the number of unread specified message objects910and the number of unread unspecified message objects930by one according to the corresponding user's reaction. Accordingly, the number910of unread specified message objects and the number930of unread unspecified message objects for the User A may be updated to one and five, respectively.

Although exemplary embodiments of the present invention have been disclosed hereinabove, it may be understood by those skilled in the art that the present invention may be variously modified and altered without departing from the scope and spirit of the present invention described in the following claims.

[Detailed Description of Main Elements]100: system of processing adialog based message object110: apparatus of processing adialog based message object120: user terminal210: processor220: memory230: user input and output unit240: network input and output310: unread message processor320: task object processor330: unread message processor340: task object processor350: task content reminder360: dialog badge processor370: controller