Providing access to a cloud based content management system on a mobile device
16 claims: 10 independent, 6 dependent
- 1クライアントデバイスにおいて、ローカル識別子をコンテンツアイテムに割り当てることと、 前記クライアントデバイスにおいて、前記コンテンツアイテムとのユーザ相互作用を検出することと、 前記コンテンツアイテムとの前記ユーザ相互作用の検出に応じて、前記ローカル識別子を前記ユーザ相互作用に関連付けることと、 共有 コンテンツマネージメントシステムへのアップロードのために、前記ユーザ相互作用をキューに入れること であって、前記共有コンテンツマネージメントシステムは複数のクライアントデバイスに前記コンテンツアイテムのアクセスを提供すること と、 ユーザインターフェースにおいて、前記ユーザ相互作用の前記 共有 コンテンツマネージメントシステムへのアップロードが完了する前に、前記コンテンツアイテムとの前記ユーザ相互作用のローカル表現を提示することと、 前記コンテンツアイテムに対するシステムワイドの識別子の割り当てを、前記 共有 コンテンツマネージメントシステムから受け付けること であって、前記システムワイドの識別子は共有仮想空間と関連付けられており、かつ、前記コンテンツアイテムを前記共有コンテンツマネージメントシステム全体に亘って特定すること と、 前記クライアントデバイスにおいて、前記システムワイドの識別子の受け付けに応じて、前記ローカル識別子を前記システムワイドの識別子で置き換えることと、を含む方法。
- 2置き換えることはさらに、前記システムワイドの識別子を前記 クライアント デバイス上のローカルキャッシュに提供することを含む請求項1に記載の方法。
- 3前記 クライアント デバイスにおいて、前記コンテンツアイテムの前記ローカル識別子を生成することをさらに含む請求項1または2に記載の方法。
- 4前記ユーザ相互作用は、前記コンテンツアイテムを 前記 共有仮想空間に追加すること、前記コンテンツアイテムを前記 共有 コンテンツマネージメントシステムの少なくともひとつの他のユーザと共有すること、または前記コンテンツアイテムを変更することのうちのひとつ以上を含む請求項1から3のいずれか1項に記載の方法。
- 5前記コンテンツアイテムは、コンテンツアイテムのコレクション、メッセージ、データ構造、画像、ビデオ、またはリンクのうちのひとつ以上を含む請求項1から4のいずれか1項に記載の方法。
- 6前記コンテンツアイテムをローカルキャッシュに登録することをさらに含み、前記ローカルキャッシュは前記 共有 コンテンツマネージメントシステムの状態を表すデータベースを含む請求項1から5のいずれか1項に記載の方法。
- 7前記データベースは前記 共有 コンテンツマネージメントシステムの前記状態の変化を検出するスレッドを実行する請求項6に記載の方法。
- 8前記スレッドは、ユーザデバイスが前記 共有 コンテンツマネージメントシステムに接続されている限り、連続的に実行される請求項7に記載の方法。
- 9前記データベースは、前記ユーザの全ての写真、前記ユーザの全てのルーム、またはそれらのルームの全てのコンテンツのうちのひとつ以上を保持する請求項6から8のいずれか1項に記載の方法。
- 10前記コンテンツアイテムは、 前記 共有 コンテンツマネージメントシステムの対応するデータと同期されたグローバルデータと、 ローカルで生成されたが前記 共有 コンテンツマネージメントシステムの対応するデータとはまだ同期されていないローカルデータと、を含む請求項1から9のいずれか1項に記載の方法。
- 11前記コンテンツアイテムへの様々なアクセスレベルを有するひとつ以上のリスナにローカルキャッシュによりアクセスを提供することによって、前記ローカルキャッシュに前記コンテンツアイテムを登録することをさらに含む請求項1から5のいずれか1項に記載の方法。
- 12クライアントデバイスにおいて、ローカル識別子をコンテンツアイテムに割り当てる手段と、 前記クライアントデバイスにおいて、前記コンテンツアイテムとのユーザ相互作用を検出する手段と、 前記コンテンツアイテムとの前記ユーザ相互作用の検出に応じて、前記ローカル識別子を前記ユーザ相互作用に関連付ける手段と、 共有 コンテンツマネージメントシステムへのアップロードのために、前記ユーザ相互作用をキューに入れる手段 であって、前記共有コンテンツマネージメントシステムは複数のクライアントデバイスに前記コンテンツアイテムのアクセスを提供する手段 と、 ユーザインターフェースにおいて、前記ユーザ相互作用の前記 共有 コンテンツマネージメントシステムへのアップロードが完了する前に、前記コンテンツアイテムとの前記ユーザ相互作用のローカル表現を提示する手段と、 前記コンテンツアイテムに対するシステムワイドの識別子の割り当てを、前記 共有 コンテンツマネージメントシステムから受け付ける手段で あって、前記システムワイドの識別子は共有仮想空間と関連付けられており、かつ、前記コンテンツアイテムを前記共有コンテンツマネージメントシステム全体に亘って特定する手段 と、 前記クライアントデバイスにおいて、前記システムワイドの識別子の受け付けに応じて、前記ローカル識別子を前記システムワイドの識別子で置き換える手段と、を備えるシステム。
- 13前記 クライアント デバイスにおいて、前記コンテンツアイテムの前記ローカル識別子を生成する手段をさらに備える請求項 12 に記載のシステム。
- 14前記コンテンツアイテムをローカルキャッシュに登録する手段をさらに備え、前記ローカルキャッシュは前記 共有 コンテンツマネージメントシステムの状態を表すデータベースを含む請求項 12または13 に記載のシステム。
- 15前記 共有 コンテンツマネージメントシステムの状態の変化を検出するスレッドを実行する手段をさらに備える請求項 12から14 のいずれか1項に記載のシステム。
- 16クライアントデバイスに、 ローカル識別子をコンテンツアイテムに割り当てる機能と、 前記コンテンツアイテムとのユーザ相互作用を検出する機能と、 前記コンテンツアイテムとの前記ユーザ相互作用の検出に応じて、前記ローカル識別子を前記ユーザ相互作用に関連付ける機能と、 共有コンテンツマネージメントシステムへのアップロードのために、前記ユーザ相互作用をキューに入れる機能であって、前記共有コンテンツマネージメントシステムは複数のクライアントデバイスに前記コンテンツアイテムのアクセスを提供する機能と、 ユーザインターフェースにおいて、前記ユーザ相互作用の前記共有コンテンツマネージメントシステムへのアップロードが完了する前に、前記コンテンツアイテムとの前記ユーザ相互作用のローカル表現を提示する機能と、 前記コンテンツアイテムに対するシステムワイドの識別子の割り当てを、前記共有コンテンツマネージメントシステムから受け付ける機能であって、前記システムワイドの識別子は共有仮想空間と関連付けられており、かつ、前記コンテンツアイテムを前記共有コンテンツマネージメントシステム全体に亘って特定する機能と、 前記システムワイドの識別子の受け付けに応じて、前記ローカル識別子を前記システムワイドの識別子で置き換える機能と、を実現させるためのコンピュータプログラム。
Independent claims16
120 paragraphs, as filed
The various embodiments relate primarily to systems and methods that provide access to cloud-based content management systems on user devices.
While photo applications, video applications and other content sharing applications are becoming more and more popular, the services and features currently offered by those types of applications have their own limitations. Recognizing these limitations, multiple online content management systems (CMSs) provide users with a convenient portal for cloud storage and the ability to interact with their content. In such a system, the user can upload content, such as a photo or video, and perform various operations, as in an application running on a supporting user device. Some of these operations can be extremely complex and can involve large amounts of content. Such operations include, for example, uploading photos or videos to a user account, receiving photos or videos from other users and copying them to their own user account, other users of the content management system. And sharing them, generating and sharing albums and collections of such content, interacting with any user-defined collection of content items or content, and interacting with sharing in various ways. Can include that.
Traditionally, there are various options for implementing a local application on a user device. For example, a local application may be implemented in a completely local way in that all content is retained and managed on the user device. Therefore, in order to share the content, the local application may rely on electronic communication to interact the content directly with another user's device. However, in this type of implementation, the amount of content a user can hold in their account is limited by the capacity of their user device. In addition, complex message and data management techniques may be required to replicate the state of exchanged or shared content items across all relevant user devices.
Alternatively, the local application may interface with an application running on a server that manages and maintains the user's content. In this implementation, the server may control, retain, and / or manage content associated with any user account on the system. The server may record any changes, shares, messages, etc. between users or between users and third parties. This server management option is not only the best opportunity to manage sharing and other interactions between users in a content management system, but also the best opportunity to retain large amounts of user data (data is the user's local device). (Because it doesn't have to be held in) also provides.
One drawback of the server-driven model is that local interactions with the user's content are limited when the connectivity between the user device and the server is high enough. If the user device is weakly or intermittently connected to the content management system server over the data network (eg, a smartphone connected to the mobile phone network), the generated content and the user's to the content management system server Actions taken locally on the user device that require data to be stored, approved, organized, or otherwise managed cannot be processed until proper network connectivity is restored. So, for example, it is possible that a user attempts to upload a collection of photos from their smartphone using a local application, but the photos are not actually uploaded to the server for hours. Therefore, content management features such as sharing, reviewing and editing may not be immediately available.
(i) generate content, (ii) add content items or messages to user accounts and other users' accessible data structures, (iii) download shared content to personal accounts on content management systems. To make it easier, and (iv) other responses to its own interaction with the application, the user can seamlessly respond to the local content management system application regardless of connectivity with the content management system server. It is highly desirable to be able to experience it. At the same time, if connectivity with the server is not guaranteed to be sufficient, the connectivity between the user interface and the local application on the user device is permanent while the connection between the local application and the remote server. This is not always possible, as can be intermittent in many cases.
Systems and methods that provide access to cloud-based content management systems on user devices are needed in the art.
Systems and methods that provide access to cloud-based content management systems on user devices are disclosed.
In various exemplary embodiments, the content may be displayed on the user device as if the content had already been uploaded to the server of the content management system, with the content added locally by the user to their user account. And all interactions with the content may be facilitated. Therefore, a server-executed content management system application running on a user device may appear to be running as a complete local application without waiting for a server response or confirmation.
In addition, content management system applications that support shared virtual spaces display changes made by the user from their user device to the shared virtual space locally immediately after the change, which changes the state of the server to the state of the user device. You don't have to wait to send the information to the server to match. Therefore, a large number of shared virtual spaces may be generated locally, and various content items may be added to the shared virtual spaces before any information reaches the content management system server. To the user, it looks like a completed task. Therefore, in such an exemplary embodiment, any image added to the shared virtual space by the user is as if (i) the shared virtual space has already been generated on the content management system and (ii) at least. It appears as if an image has already been copied into a shared virtual space, and any messages or posts added to or associated with such images are displayed as well, and even all with them. Interaction is promoted as well. Similar functionality may facilitate the addition of content to existing shared virtual spaces.
In certain embodiments, the user device may include a user interface module and a processing module. The processing module may handle all network communications. The processing module may be communicably connected to the user interface module via a direct connection, or may be communicably connected to the content management system via a wireless connection. The processing module may include a listener module capable of registering content items and content data structures generated in the user interface module.
The user interface module may accept user requests for adding content items to user accounts and / or interacting with content items and other data. The requested additions and interactions may be stored in the processing module's local data store, along with each content item or data structure referenced by the local identifier. The local identifier may be passed to (i) the user interface module and (ii) the processor module whose content items and content data structures are registered in the listener module.
When a user makes a local request to add content or interact with content or content data structures, the user makes the result of such request as if the request had already been executed on a content management system. It may be expressed locally substantially immediately after the request is received. In parallel, the processing module may queue the request for upload to the content management system server, and as soon as it is uploaded, the server may assign a global identifier to the content or interaction associated with that request. ..
When the user device accepts the global identifier, the processing module may pass the global identifier to any content item or content data structure registered within the user interface module and / or listener module. The previously assigned local identifier may be replaced with a global identifier. This process may occur seamlessly from the user's perspective. As a result, the user does not have to be aware of whether a particular content item or data structure is associated with a local or global identifier.
Therefore, in certain embodiments, the content management system application on the user device may include a user interface module and a processing and network communication module. The user interface module may be communicably connected to the processing and network communication module, and the processing and network communication module may be intermittently connected to the server of the content management system via the data network. User request actions may be performed substantially immediately within the user interface module, regardless of the state of the network connection between the user device and the server. Parallel requests may be sent over the data network by the processing and network communication modules to the content management system when the network connection allows.
Therefore, the results of all user-requested actions may be presented within the user interface module as if they had already been implemented in the content management system. This allows the user to interact with all content (as known to the user device at that time) as if all user request actions occurred at substantially the same time as the request.
When the network connection allows, the processing and network communication module may accept confirmation from the content management system that the user request action has been performed. Based on the received confirmation, the state of the user request action of the user interface module may be matched with the state of the user request action of the content management system.
The above and other aspects and advantages of the present invention will become more apparent by considering the following detailed description in conjunction with the accompanying drawings. In the accompanying drawings, similar reference numerals indicate similar members throughout.<figref num="1">Illustrative systems according to various embodiments of the invention are shown.</figref><figref num="2">It is a schematic diagram of a simplified exemplary network in which three user devices connect to a content management system server via three data networks.</figref><figref num="3">A flowchart showing an exemplary normal process for uploading photos on a user device and sharing them with other users, according to a server management content management application, is shown.</figref><figref num="4">It is a schematic diagram of a user device and two modules thereof which concerns on an exemplary embodiment of this invention.</figref><figref num="5">It is a flowchart which shows the process for uploading a photograph in a user device and sharing them with other users which concerns on various embodiments of this invention.</figref><figref num="6">Other exemplary systems according to various embodiments are shown.</figref>
Systems and methods that provide access to cloud-based content management systems on user devices are disclosed. In various exemplary embodiments, the content may be displayed on the user device as if the content had already been uploaded to the server of the content management system, with the content added locally by the user to their user account. And all interactions with the content may be facilitated.
This feature may be incorporated into existing content management systems or services, or may be provided as a separate application, or is one of many features in separate applications that provide enhanced content management services. May be provided as. The exemplary content management application may be run on a user device, such as a smartphone, or may access the user's account registered in the content management system. Such applications may support complex multi-party interactions such as shared virtual space features. Content management applications that run locally on the user device may eventually be supported by one or more such servers, but the shared virtual space as if the application were running locally on the user device. Extensions may be available by using a content management application so that the functionality is visible. This depends on whether the user device is weakly connected to the server, intermittently connected, or disconnected. By allowing the user to feel that the user's device is sufficiently interactive even when the connection is restricted, the user experience and feature richness provided to the user can be greatly improved. ..
In the following, the terms "device" and "content management system" broadly refer to a wide range of storage providers and data management service providers, as well as electronic devices and user devices. Used as a thing. Also, "content item (content) The term "item)" broadly refers to a wide range of digital data, documents, text content items, audio content items, video content items, parts of content items, and / or other types of data. is there. Content items can also include files, folders, or other mechanisms that group content items together with different behaviors, such as collections, playlists, and albums of content items. Here, the term "user" is also widely used herein, a single user, multiple users, an authenticated account, an application or program that operates automatically or by human command instead. , Any other user type, or any combination thereof. Here, the terms "gesture" and "multiple gestures" are also widely used herein, one or more movements, movements, hovering, reasoning, signs, or one or more sensors. It may correspond to any other physical interaction with, or any combination of these, such as speech commands or interpretation of eye movements based on retinal tracking. "Continuous real-time image" is also widely used in this and is a live image, a continuous image taken, a recorded image, or an image taken through one or more capture components. It may correspond to any other type of image that can be captured via the imaging component, or any combination thereof.
The present invention may embody various components and component placement, procedures and placement of various techniques, methods, or steps. Referenced drawings are for purposes of illustration only, and are not to be construed as limiting the invention. The features of various inventions, each of which can be used independently of each other or in combination with other features, are described below.
FIG. 1 shows an exemplary system that follows various embodiments. The system 100 includes user devices 102a and 102b that communicate with the content management system 104 across the network 106. Those skilled in the art will appreciate that only two user devices are shown in system 100, but any number of user devices interact with the content management system 104 and / or network 106 and the above description is merely exemplary. recognize.
Network 106 includes, but is not limited to, Transmission Control Protocol and Internet Protocol (TCP / IP), Hypertext Transfer Protocol (HTTP) and / or Wireless Application Protocol (WAP). , Can include any number of protocols. For example, the user device 102a and the user device 102b (collectively 102) communicate with the content management system 104 using TCP / IP, and at a higher level, communicate with the web server in the content management system 104 using HTTP. A browser can be used to do this.
Various user devices 102 include, but include desktop computers, mobile computers, mobile communication devices (eg, mobile phones, smartphones, tablets), televisions, set-top boxes, and / or any other network-enabled device. Communicates with the content management system 104, not limited to. Various types of user devices can include smartphones, mobile phones, tablet computers, personal digital assistants (PDAs), laptop computers, digital music players, and / or any other touch-sensitive display interface. It can include, but is not limited to, a type of user device. Various touch-sensitive display interfaces include liquid crystal display (LCD), monochrome display, color graphics adapter (CGA) display, enhanced graphics adapter (EGA) display, variable graphics array (VGA) display, and any other display. , Or any combination thereof, but not limited to. In certain embodiments, the touch-sensitive display interface may include a multi-touch panel connected to one or more processors to accept and detect gestures. A multi-touch panel is, for example, a capacitive detection medium having one or more row traces and / or driving a line trace and having one or more column traces and / or detecting a line. possible. The multi-touch panel is described herein as an example of a touch-sensitive display interface, but those skilled in the art will recognize that any touch-sensitive display interface will be used. Moreover, various types of user devices may include one or more imaging components in certain embodiments. For example, the user device 102 may include a forward facing camera and / or a backward facing camera.
The content management system 100 allows users to store content using authenticated accounts and also performs management tasks such as searching, modifying, browsing, synchronizing and / or sharing content with other accounts. In certain embodiments, the corresponding user interface on the user device 102 (eg, stand-alone application, client application, etc.) is a content management interface that allows the user to perform the functions provided by the modules of the content management system 104. It can be implemented using modules. A more detailed description of System 100 is shown below with reference to FIG.
Figure 2 schematically illustrates a simplified exemplary network of three users on three user devices (eg smartphones), each connected to a content management system server across a network (eg a mobile phone network). Shown in. Referring to FIG. 2, a content management system (CMS) server 200 and user devices 202a, 202b, 202c are shown. The user device 202a is connected to the CMS server 200 via network 1 206a, the user device 202b is connected to the CMS server 200 via network 2 206b, and the user device 202c is connected to the CMS server 200 via network 3 206c. To. Since the user device 202a-c is connected to the CMS server 200 via a different network connection and may be physically located in a different location, the interaction over the network connection may involve different network delays. And one or more of the user devices 202a-c may experience loss of network connectivity at various times of the day.
Although the content management application is implemented locally on each of the user devices 202a-c, contention between users can occur. For example, if each of the three users requests to create a virtual space shared by all three users, the request from user device 202a is issued earlier than the request from user device 202b. In spite of this, the CMS server 200 may be reached first. Therefore, the server may consider the user device 202a to initiate the shared virtual space, even though the initial request to create the shared virtual space originated from the user device 202b. Such race conditions can have undesired consequences, such as duplicate duplicates of content items and shared virtual space on the CMS server 200 and / or user device 202a-c.
The schematic network in Figure 2 shows that if a content management application running locally on user device 202a-c should provide full interoperability, that application will connect to the CMS server 200. Show how you need to maintain a high quality of service that is sufficient to support the required bandwidth. Due to network connectivity issues, (i) objects are created (eg, users try to upload photos) and (ii) multiple participants before at least some of the relevant content is accepted by the CMS server 200. , Multiple content item data structures and data structures are generated (eg users create shared virtual spaces), (iii) users interact with content items and data structures, and many other instances occur. sell. Various systems and methods according to exemplary embodiments of the invention are effective for such instances.
Examples of complex locally generated content and its interactions with it: "Room" To fully illustrate some aspects of the invention, local interactions for shared virtual space features are referenced. Such functionality is described in detail in US Provisional Patent Application No. 61 / 945,814, filed under the common assignment of the present application, entitled "Systems and Methods of Providing Shared Virtual Space." The disclosures of that application are incorporated herein by reference.
A room application describes a virtual space shared by multiple participants and may be known as "rooms" or a single "room". A room may be defined as a virtual space accessible by a set of users in a content management system. There, users may share content items and messages about the items with each other. The content management system may manage the user's room and all content items, messages, and their associated interactions. Multiple participants in a room may include the creator of the room, all others who shared the original content with the creator, and / or others invited subsequently. These participants may be referred to as "members" of the room.
In certain embodiments, the room may be automatically generated whenever a user of a content management system shares a content item or a message about the content item with another user. In one example, a sharing request may be accepted to share one or more content items with one or more of the user's contacts. Upon acceptance of the sharing request, a room containing a copy of one or more shared content items and a link to it may be automatically generated. The room may be associated with an allocated memory location on the system server (eg, data store 118 in Figure 1). The room may be accessed by both the user and other members, and each member may add additional content (eg, content items and messages) to the room. All member participants may be notified whenever any content is added to the room. In certain embodiments, other non-members may be notified, or even those who are not registered as users of the content management system. Notifications are in-band (ie, via communications within content management systems or through applications provided by such systems), out-of-band (eg, via email, SMS, social media notifications and posts). ), Or any combination of these communication paths.
A room can be said to have "members" as used in the room application. Depending on the embodiment, the member may be an exclusive registered user of the content management system that provides the room function. In other exemplary embodiments, unregistered users of the content management system may be designated as members of the room in whole or in part. In these embodiments, a given person may be a member of the room, regardless of his or her status as a registered user of the content management system.
In one embodiment, to members of the room, copy any content in the room to their personal account on a content management system, and / or to others via email or SMS. You may allow you to freely send copies or post to social media applications. Because the room is a permanent or semi-permanent data structure designed to retain room content and facilitate interaction with room content, each invited participant in the room has access to the room at any time and is convenient. Is. In certain embodiments, content items added to a room may be copied and locked in a separate "rooms" database. That is, even if the original owner of the content item later modifies the original content item in his user account, such changes may not apply to the content item outside the room. .. Any content added to the room may be saved in the room for a predetermined period of time, which may be indefinite, for example.
In one embodiment, local changes requested by the user to the shared virtual space (eg, adding content or posts, adding new people, etc.) are displayed locally as soon as the changes are requested. You may. It may not be necessary to wait for the changes to be sent to the server before displaying the changes locally. Therefore, many rooms may be generated locally, different content items may be added to the room, different persons may be added as members to the room, and these may be added to the room as members of the content management system. It may occur before it reaches the server. To the user, it may appear as if the request was completed as soon as the interaction occurred. This function may be enabled by the systems and methods of the present invention. Therefore, the "room" function may serve as a clear example to illustrate the various aspects of the invention. The complexity of such a room highlights the challenges solved by the various embodiments of the present invention.
As mentioned above, in various exemplary embodiments, the user content and its interactions may ultimately be managed by the server of the content management system. However, the user may interact with the content management system via a user interface provided by a content management application running on a user device that communicates with the server over a data communication network. In such embodiments, (i) generate content items or content data structures (eg, photos, videos, "rooms", etc.), (ii) add content items or messages to user accounts or existing rooms, The user of the user device provides a seamless response of the user interface with respect to (iii) downloading content from the room to a personal account within the content management system, and (iv) other responses to the user's interaction with the application. It is highly desirable to be able to experience it. These objectives are easy because the connectivity on the user device between the user interface and the content management application is permanent, while the connection between the content management application and the remote server can often be intermittent. Not always achievable.
In certain embodiments, the content may be managed with reference to a unique index number or an identifier assigned or associated with the content. In a standard content management system, each user is assigned a unique identifier, and all content and interactions for that user are supported as the content management system properly accumulates content items in its account. Unique identifiers may be utilized to allow various interactions to be implemented in the account.
The behavior may look essentially the same to the server, regardless of whether the user creates the room by initiating the sharing of content or adds the content to the room. However, in the former case, the room ID does not exist when the sharing is done, while in the latter case, the room ID already exists. When the user first creates a room, the request for the room ID may be sent from the content management application to the server of the content management system. If the content management application has to wait for the room ID to be received from the server, the application cannot generate the room or present content within the room until the room ID is received. This process can cause a wait state if the connectivity between the client application and the server is intermittent. If the server is not responding to actions or the server is not meeting the request so that weak or intermittent data connections between the user device and the remote server do not spoil the appearance of full local functionality. The action requested by the user may be reflected in the user interface even if the server is not processing the request.
For example, in a simple case, the user decides to create a room even if the user device has a weak or intermittent connection to or is not connected to a server in the content management system. May be good. The user may select many content items to share in the room and many to add to the room. Upon sharing, the content management application may create a room on the user device. At that point, the content management application may notify the user interface of the new room, or at least attempt to inform the server of the new room. If the server is not accessible at that time, the message informing the server of the new room may be queued as it should be sent to the server when the appropriate network connection becomes available. In any case, if the user adds a comment to the room, it may appear in the room with the local user interface, even if the message has not yet been sent to or processed by the server. That is, something must be done locally to "fill the gap", as a user can be embarrassed if he or she does not see the comment for a significant amount of time when commenting on the room. Thus, even if the connection is still poor or absent, in an exemplary embodiment of the invention, the user can nevertheless experience a smooth, near-seamless local experience. In such an embodiment, the content management application may simulate activity on the user device while waiting for the server to later send the message "Create a room and assign a room ID". ..
To simulate activity, the content management application may generate a local ID and a new post table (eg, a table that manages which posts are in rooms, which rooms are, etc.). The content management application may generate these results locally, as if the new room existed globally and the content was really posted to the room. The global room ID may be associated with the local room ID and the local room ID may be replaced with the global room ID to maintain seamless interaction on each user device when the server responds. If the local room ID is included in a queued instruction to prevent the action from being executed twice, or to prevent the action from being executed at all, the instruction is queued but still being executed. ID exchanges may occur during the absence or after the instructions have been performed. Uncertainty can arise if the exchange occurs while the instruction is being performed.
For example, a user may take a picture on a smartphone, and the user may be running a room application on that smartphone and try to share the picture with one or more other users in a new room. If the smartphone is not connected to the content management system's server (for example, due to network issues), the photo and room generation requests are executed locally while being queued for uploading to the server. You may leave it as it is. Therefore, only the local ID may be associated with these photos and the new room. The task of requesting a global ID for a room or each photo and the task of adding a photo to a room may be queued while being performed locally. If the connection with the server is restored while some of these instructions are being executed, make sure that the task is complete and that the task is not executed twice (ie, refer to the local ID). The first run will be done, and the second run will be done with reference to the global ID), and you will need to manage the replacement of the local and global IDs.
Traditional (server-based) approach To show how a slow, intermittent, non-existent, or otherwise poor network connection introduces a large wait state, Figure 3 shows a traditional content management system application running on a user device. An exemplary processing flow is shown. In the exemplary traditional application shown in Figure 3, the content items, data structures, and behaviors generated by the user are managed until the content management system approves the generation and assigns a global ID to the objects, structures, and behaviors. There is no way or system to do it.
Referring to FIG. 3, the process flow begins at the beginning and proceeds to step 310. There, user A uploads a photo and shares the photo with user B and user C via the user device. For illustration purposes, the application shown in Figure 3 is a content management application that incorporates the new "room" features described in the room application but is portrayed as if it were implemented in a traditional server-based system. In such an application, a user can create a shared virtual space by sharing a content item, such as a photo or video, with one or more other users on a server in a content management system. The server of the content management system manages the receipt of content items, the creation of rooms, and the subsequent communication with the user devices involved. Once the initial sharing is made, there may be a shared virtual space managed by the content management system. Therefore, in step 310, the following two logical objects may be created. The server accepts (1) content items uploaded from user A's user device to that person's account in the content management system, and (2) content items designated to be shared with user B and user C. A shared virtual space that may later be defined by a content management system. Therefore, there are two objects that need to be assigned a global ID. In addition, content management systems need to associate content items with shared virtual spaces. This association may be reflected in the records associated with the shared virtual space.
The process flow proceeds from step 310 to step 320, where the user device processes the user action described in 310. Therefore, the user device requires a global identity for the content item and shared virtual space. Here, it should be understood that only the global ID exists in the explanatory process of FIG. When the content item is shared with users B and C, a shared virtual space may be created by user A. It is called the "ABC Room". This is because it is easy and convenient to specify a room or shared virtual space according to the members of that room. As mentioned above, not only do we need global IDs for both of these objects, but we also need to send instructions to associate content items with ABC rooms by their global IDs.
The processing flow proceeds from 320 to step 330. The difference from the present invention exists here. That is, the user device of the content management system before it can treat those objects as existing and / or before it displays those objects within the content management application on the user device. You have to wait for the global ID to come from the server. If there are no network delays or connectivity issues, the user will not experience any delays or artifacts due to step 330. However, unless there is network delay for some reason, or there is network congestion, or for example, a user is accessing a content management system via a cellular network using a smartphone and the user has almost no signal. If you are traveling in an area that may or may not exist, there may be a long period of time when the user device is disconnected from the network. In such cases, step 330 can be very frustrating. Until the photo is displayed in the content management application, the content item can be shared, the room exists, and the content item is displayed in the room, the user can spend seconds, minutes, hours, or You may be required to wait longer.
The process flow goes from step 330 to step 340, where the user device accepts global IDs for (i) content items and (ii) ABC rooms, respectively. The process then proceeds to step 350, where the user device uses the global ID here to (a) store the photo in the user's account, (b) generate an ABC room, and ( c) The photo may be stored in the room's database so that it is associated with and displayed in the ABC room. The process goes from step 350 to step 360, where the user device displays the photo in user A's account, displays the ABC room within the user's content management system application, and displays the photo within the ABC room. To do. The process flow ends from there.
As mentioned above, whenever the user device is barely connected, weakly connected, or unconnected to the content management system, the user will experience the major drawback of the process flow shown in Figure 3. Let's go. In order to improve this situation and prevent accompanying wait states, race conditions and other defects, the exemplary process flow shown in FIG. 4 may be implemented in various exemplary embodiments.
Division of user device into user interface module and processing module; function of each module In an exemplary embodiment of the invention, the user device may be split into two modules. This is schematically shown in FIG. With reference to it, the user device 410 has a user interface (UI) module 415 and a processor module 420. UI module 415 has a permanent connection (such as by wiring) 430 with processor module 420. Processor module 420 may handle network communication. The processor module 420 has an intermittent connection 450 with a content management system (CMS) server 460 via a data network 440.
Processor module 420 may include software sharing libraries that can be used on various computer platforms, including, for example, Android® and iOS type devices. As mentioned above, the processor module 420 maintains a connection with the CMS server 460 and thus exchanges information between the server and the content management application running on the user device 410. Processor module 420 provides UI module 415 with a view of the user's account, taking into account both global and local data. Thus, for example, in a room application, the processor module 420 may provide data about the user's room and the content of each room. That data combines (i) data that is synchronized with the server and (ii) data that is locally generated but not yet synchronized with the server.
In an exemplary embodiment of the invention, the processor module 420 may include a database referred to as a "cache". The cache is basically a server-state local cache. This "cache" database may hold all of the user's photos, all of the user's rooms, and all of the content in those rooms. The database may be kept up to date, for example by a "delta" thread. A delta thread is a continuously running process that runs when the user device has sufficient connectivity with the CMS server 460, for example informing the server that "I have all this data up to point A". It may be. The CMS server 460 may then respond that the cache is up to date or provide new information that needs to be added to the cache. If user device 410 is not generating new data, the delta thread runs, accepts changes from the CMS server 460, and applies the changes to the cache. Therefore, it is relatively simple if the user does not actually add content or interactions. The UI module 415 basically requests the processor module 420 for the contents of, for example, a given room or set of rooms. Processor module 420 then references the cache and returns the current data. When this delta thread changes, processor module 420 may push these changes to UI module 415 if the UI module expresses interest in a particular room or set of rooms. As will be fully explained later, UI module 415 may express interest by registering listeners for the room. This eliminates the need to push updates to all individual caches from the processor module 420 to the UI module 415, thus reducing processing and minimizing power consumption.
In certain examples, the user may be a member of several rooms. However, it may be only a small subset of those rooms that the person actually sees and interacts with. Interest is expressed in those rooms. However, for rooms that the person hasn't visited for six months, there's no need to push cache changes, and there's no need to alert the user about changes to the content of such rooms.
Listener function In an exemplary embodiment of the invention, as described above, UI module 415 may express interest in a content item or other user or room, for example by registering a "listener" for that content. For example, there may be room listeners, post listeners, or even "room member" listeners. Therefore, when a delta thread is executed, it may pick up changes in server state and determine if any of the registered listeners are interested in those changes. If so, methods for these listeners, saying, for example, "There's a new room here, there's an updated room here, there's a new post here, there's a photo here that goes into this post" May be called.
It's a simple case where the user hasn't actually changed anything. A more complex case is when the user is generating local content via UI module 415. In such cases, there may be data or states that have already been stored in the local database but have not yet been sent to the CMS server 460. This data may also be stored in the user device "cache" of processor module 420 for persistent retention. Thus, if a user generates a post and then, for example, that person's smartphone crashes, the application may save the post. As a result, when the user restarts the phone, the post can be sent to the content management system server without loss.
In an exemplary embodiment of the invention, the user's interaction with the content management application may generate various behaviors. Such actions may be sent to the action queue. For example, the action taken by the user on the room may be represented in the action queue. These actions, for example, create a new room, create a new post, add a member to a room, save a photo from a post, or "read" a room to stop users from receiving notifications about the room. May include marking. All of these events can affect the user view of a room or list of rooms. Therefore, all of them may be applied on top of the existing state to show the user the proper UI view. So what the user wants to see is (i) in the database, an existing state matched with the server, plus (ii) queued to be on top of that state to get what the UI should represent. All replays of local actions that have been made. So, for example, if you have two rooms (from a server perspective) and the user adds two new rooms (from a user device perspective only), those two new rooms have not yet been sent to the server. Even in that case, the UI module 415 may show the user all four rooms when the user uses the application.
As an example, the following simple case is provided. The user may already have one or more rooms in the cache and request some new rooms in the operation queue. For example, these new rooms may not yet have been sent to the CMS server 460 because the previously queued operation is still performing or the user device does not have a proper connection. UI module 415 may then register the listener. In an exemplary embodiment of the invention, UI module 415 may then fetch information about the room that the server already knows from the cache. Processor module 420 may then perform operations in the order in which they were generated and update the user's room list to add two new rooms. The two new rooms are known only locally at this time. If the behavior modifies an existing room, processor module 420 may modify the copy of the room fetched from the cache. This is due to, for example, incrementing the number of posts, adding new messages, and adding new content items. Processor module 420 may add to the list of rooms already cached if the behavior corresponds to a new room. Therefore, after taking cached data and combining it with operation queue data, the processor module 420 may have a set of information that can be sent to the listener. For example, processor module 420 may own a view of the room that needs to be shown to the user in the UI.
Therefore, it will be understood that the behavioral view may be local to the user device. In addition, keep in mind that some operations can be delayed before they are sent to the server. For example, if a user shares 10 photos and all 10 photos have not yet been camera uploaded (ie, have not been added to the user's content management system), the photo sharing action may not proceed before proceeding. You can wait until 10 photos have been uploaded. Other actions may be performed on the device while the shared action is stuck, but no other actions may be performed on the room. Therefore, in that sense, the pending upload may act as a blocker for everything in the room. Therefore, it should be noted that the action queue is a bit more complicated than just first-in first-out.
In an exemplary embodiment of the invention, if the user adds content, or if the user takes some action through the UI module 415, eg, add a post to the room, the processor module 420 will do so. May send parallel commands to the CMS server 460 as it processes its operation locally. The CMS server 460 may then process the command by updating the server database and pinning the devices of all users running the content management application. As a result, each such device runs a delta thread and applies its state to the cache database as described above. If the delta thread does not work (eg due to lack of network connectivity with a particular user device), it may, for example, continue to retry. As long as the user device is running a content management application, the delta thread can attempt to communicate with the server. In addition, if a connection is lost, the delta thread can wait for the connection to regain.
Revisiting the schematic network shown in Figure 2, if user device 202a-c modifies an existing room or attempts to create the same room with the same people, some or all of them As a result of losing connectivity, and because all user actions are processed locally as described above, each of the user devices 202a-c is known to everyone plus only that person. You may only recognize that. Therefore, two or three of the users in Figure 2 may each generate the same room and put a different set of photos in it. When all user devices return to the connected state, everything converges in the order written to the server database, so the content management system server registers a new room and each of the user's delta threads is with the content management system server. Upon synchronization, the local view may change. Therefore, a local activity can be modified to the extent that another activity (the local device did not know about the other activity when it was performed locally) overwrites the local activity.
In an exemplary embodiment of the invention, this process may operate in the following embodiments: All posts in a room, along with all rooms, may have a "sort key" associated with them. The sort key on the server may be generated, for example, from a time stamp that records the time the item was written to the server database. The sort key is like a string, like "aaa" or "aab", which knows how the device sorts. In such an exemplary embodiment, anything that the user generates locally will have a sort key that is guaranteed to be larger than anything on the server. Therefore, anything that you generate locally may be sorted to basically the latest edge of everything on the server. However, as it is written to the server, it may accept new sort keys based on when it arrives at the server. Thereby, everyone (ie, all members) can finally get a consistent view of the room.
Therefore, when a user adds a post, the command to the server to add the post returns a new server representation of the post. It is written to the user's local cache, and at the same time the operation is cleared. Thus, in that case, the user-local view of the room could probably change, for example, if the person took a picture and viewed it offline.
Thus, for example, due to the involvement of multiple participants in the room and, as described above, each of them intermittently accessing the content management system server, as shown in FIG. As you can see, a member of a given room, eg, an "AMN room", may look at post A and add post B, so that person may add post A and post B to the AMN room on his device. I see. In addition, other members of the AMN room may be offline, have post A in the room, and then add post C. Therefore, the member may see Post A on his device and then Post C in the same room. Both users will eventually end up in either Post A, B, C or A, C, B in the AMN room, depending on, for example, which user first regains connectivity.
In an exemplary embodiment of the invention, a consistent (global) sort key is obtained as each user device regains a connection and writes the action to the server, so for example both members of the AMN room are the same. Will see. Ultimately, some rule must be selected to resolve such conflicts. Such a rule may be, for example, that the first saved in the content management system wins. Therefore, for a given user, a post may be inserted above that user's post when that user comes back online.
If two users create a room with each other, or if, for example, they create a room with the other and the same additional participants, and the two users are both offline, then they are of other interest. There is a case. In one embodiment, a room is defined on the server by a unique set of people who are members of the room, as described in the room application. Therefore, both of those posts will be displayed in the same room by the content management system. Because if Alice shares content with Bob and Bob shares content with Alice, it's Alice-Bobroom on the server, regardless of which command first arrives at the server. Even if they both do it when they are offline, they will end up with the same global ID for the post and the same global ID for the room when they both come back online. This is because the server simply matches them, and even if room creation occurs offline for each of them, they do not end up in two separate rooms. The only difficulty is that no matter who first comes back online, that person's post will be listed first in the room. This assumes that the posts are listed in chronological order in the room.
However, in a related example, user A creates a room with users B, C and D, user B creates a room with users A, C, E and F, and both users A and B are then offline. In some cases, each first looks at the generated room with such a post, whatever the post they added to the room. Thus, User A sees an ABCD room on his user device with whatever photo he originally added to the room, along with the post he subsequently added. Similarly, User B sees an ABEF room on his user device with whatever photo he originally added to the room, along with the post he subsequently added. However, when each comes back online, both the ABCD room and the ABCEF room will be present. The former involves content from user A and the latter involves content from user B. Users A and B each intended to share content with each other, but if the two rooms are not merged, the content cannot exist in the same room. As mentioned in the room application, each unique set of users is their own room, and there are posts within the room. Within each post are items such as photos and messages.
Note that processor module 420 defines the interface that the listener must implement, but the actual implementation is done in UI module 415. Thus, in one exemplary implementation, the processor module 420 tells the UI module 415 that "you need to create an object with these methods", and then the UI module 415 is on each platform. Generate an implementation for each listener in. Therefore, the listener dies when the listener is generated and then no longer needed by UI module 415. Additionally, in one exemplary embodiment, UI module 415 does not have to express interest in the posts in a given room until the user actually sees it. However, in such an exemplary embodiment, for a list of rooms, UI module 415 may maintain it for as long as the application is running. In this case, the list of rooms can be shown to the user as soon as the user slides open the panel. In one embodiment this may simply be a list of rooms, in other embodiments it may be both a list of rooms and a notification of new posts added to the room.
It is understood that the criteria by which UI module 415 determines what listeners to register may vary and may depend on several factors. The goal is to create listeners for any type of content that the user is likely to want to display in UI module 415. It may be, for example, recently viewed rooms and content, where "recent" may be defined using various scales, or in rooms and content that are frequently attended or interacted with. There may be.
Replacing a local ID with a global ID In an exemplary embodiment of the invention, all content may be assigned two identifiers. For example, in a room application, both the room and the post may have two IDs or up to two IDs. The same is true for any type of content or content item in standard applications such as photos and videos. Therefore, any post written to the server or any room written to the server may have a global ID. The global ID may be, for example, an Edge-stored 128-bit number, another number, or a sufficiently large string. In general, the global ID needs to be large enough to uniquely identify all content throughout the content management system. However, as is clear from the above description, local IDs that refer to posts and rooms that are locally generated but have not yet been sent to the server, for example, are also needed to support all offline operations. Therefore, in an exemplary embodiment of the invention, when the UI module 415 generates content items such as photos, posts, rooms, etc., the UI module 415 accepts a local ID from the processor module 420. UI module 415 may continue to use its local ID as long as it needs to. As described above, when the operation reaches the server, the processor module 420 may update all operations that refer to the local ID in the queue with the newly accepted global ID.
Nevertheless, look-up tables, translation tables, etc. may be maintained. This is because, for example, UI module 415 has a local ID. In the case of creating a room with X and continuing to tell processor module 420 to add various posts to room X, inside processor module 420 room X is already in room Y with a new global ID. If upgraded, processor module 420 requests these incoming requests from UI module 415 to post to room X, which is due to UI module 415 knowing room X by using the old local ID. This is because it needs to be able to translate to room Y, that is, to the global ID used locally in processor module 420 (and globally on the content management system server). Therefore, in an exemplary embodiment of the invention, the translation table that associates the local ID with the global ID may be maintained for a sufficient period of time to eliminate the behavior of coming from UI module 415 and referencing the local ID. Good. However, after such a period it may be discarded. This may be, for example, when the application on the user device is restarted as described below.
Additional usage of local ID: post-validity; local ID persistence In the discussion up to this point, there is sufficient local functionality, and basically immediate with the newly generated content and the data structures for organizing such content (eg, rooms, albums, collections, etc.). Local IDs may be used internally on the user device to facilitate interaction. However, the local ID may have other uses. Therefore, in an exemplary embodiment of the invention, a local ID may be used to guarantee the validity of an item when generating content such as a room or post.
A potential challenge is for the processor module 420 to tell the content management system server to create, for example, a new room, such as room ABC. However, the response from the server to the processor module 420 tells us that the room was actually created, which can be lost due to a user device crash, loss of network connectivity, and so on. In such a case, the processor module 420 will continue to retry this operation until the CMS server 460 tells it that the generation was successful. To the server, retrying such a request looks like multiple requests. However, if each of these actions to generate content, such as a room or post, is tagged with a globally unique local ID assigned by the processor module of the user device, then the server will do these second time or You can ignore the third request and simply return the same global ID that it has already generated. It may look for a request with the same local ID and discard it as a duplicate. That way, if the user device sends a request to the server to generate something more than once, no duplicates will be generated. Therefore, in various exemplary embodiments, the local ID is useful both from the translation into the UI perspective and to ensure the validity of the item.
Therefore, in such an exemplary embodiment, the processor module 420 may send a request containing a local ID to the CMS server 460. Such a request may have, for example, the form "User A creates a room with users M and N, local ID AFF2 B994 D223 1178 User A's device XYZ". The content management system server may then track these local identities, for example to reject or simply ignore later duplicate requests for the same content item or room.
Therefore, when the room is first created, there is a local ID assigned to it. As soon as its first request to create a room arrives at the content management system server, the PM looks at the action queue and updates all pending actions for that room to use the accepted global room ID. To do. However, in certain embodiments, it should be noted that for a post ID, every individual post has a local post ID, even if it was generated for an existing room. The post ID is used only inside that particular post and is therefore not replaced. Because they disappear with the operation as soon as the operation succeeds on the server.
However, the local room ID may be destroyed as soon as the room is created. In certain embodiments, UI module 415 may maintain its local ID until it restarts. However, the next time the application restarts in UI module 415, the user device will not know anything about its local room ID. Therefore, there is a translation table to deal with the discrepancy between the UI module 415 and the processor module 420 (when the PM accepts the global ID from the content management system server). In an exemplary embodiment, it is desirable for UI module 415 to be able to refer to content, posts and rooms by their ID, in which case processor module 420 simply translates them as needed. As mentioned above, once the application is restarted, it may not be necessary to save the translation table.
It should be noted that there is another interesting aspect of local identities, namely push notifications. Push notifications are commonly used on the iPhone®, where the server sends a message to the user, which appears as a small pop-up message or notification. It can also cause the user to launch an application. This is like, for example, a user receiving an email or alert from CNN, The Weather Channel®, etc. and tapping a pop-up or notification to go to the relevant website. In the context of the present invention, such push notifications may essentially be used as a connection between the CMS server 460 and UI module 415. The connection is not mediated by the processor module 420 of the user device. The following is an exemplary scenario. When a user creates a room with a content management application running on their iPhone®, the UI module stores the local ID of the room in memory. After the server generates the global ID for the room, if the iPhone® processor module has not yet received a message reply from the content management system server, and someone will be in the room within the next few minutes. When responding, the content management system server may, upon seeing the response, send a push notification to the original user's iPhone®, which is the global ID of the room or its abstract or its content. May have a link to. There are very strict restrictions on how large these notifications can be, so there is generally not enough room to include the local ID as well.
Therefore, the content management system server may send a remote ID. Because it's convenient for everyone as long as posts from other room members have already reached the server. Therefore, this is a way for remote IDs to quickly return to the UI module without going through the processor module.
Figure 5: Illustrative process flow within a room application With reference to FIG. 5, an exemplary processing flow according to an exemplary embodiment of the present invention is shown. The process flow begins at the beginning and proceeds to step 510. There, user A uploads a photo and shares it with user M and user N on the user device. Or, for example, user A shares an existing photo with users M and N. This function is similar to 310 in Figure 3 and creates multiple objects. Multiple objects need to be identified by the content management system so that they can be implemented or executed. For example, when User A uploads a photo, he creates a new content item that must be assigned an identifier. When a user further shares it with two other users, such as User M and User N, a room is created as described above and in the room application. The room must be assigned an ID and will be implemented. "Implementation" shows that the room appears in the user's account on the content management system. Alternatively, if the user only shares an existing photo with users M and N, this because the photo already has an ID, seemingly a global ID, and there is no reason to generate a new one. Only rooms are generated by user actions.
However, this process actually involves many steps. A room must be created and assigned an ID (ie, "room ID"). In addition, as described in the room application, for example, it is placed in the room by (i) sharing the content item with the members of the room first, or (ii) later sharing the content item within the existing room. For any content item, you must make a copy of that content item and store it in a separate database. At the same time, the original must be stored in the sharing account. This is to prevent it from changing. This is the protocol of some exemplary embodiments of the room and is more fully described in the room application. In addition to producing a separate copy of the photo or content item, it may be associated with a room in the record. The record holds information about all items and members in the room and the interactions of the members in the room with respect to those content items. For example, in one exemplary embodiment, room members (i) post a message about the content item, (ii) copy the content item to their account, and (iii) otherwise if desired. You may execute the task. For each of them, instructions will be issued on the user device that refer to the identifiers of the objects involved and the identifiers of the rooms involved.
The processing flow branches from step 510 and proceeds in parallel with steps 520 and 525. This branch is novel according to an exemplary embodiment of the invention that facilitates seamless interaction on the user device, even when the connection to the network is cut off or intermittent. It explains the function. Referring to 520, the processor module of the user device requests the global ID of the photo and the global ID of the "AMN room" generated by the sharing in step 510. This is quite similar to 320 in Figure 3. However, in parallel and without delay or wait time (ie at the same time), at 525, the processor module assigns a local ID to the photo and AMN room. This allows the photo, as well as the room, to "exist" on the user device, even if it is not officially recognized by the content management system server. Further, this parallel processing may start as soon as the user action in 510 occurs. This allows you to avoid delays, generate seamless local interactions, and make them feel to the user.
The processing flow proceeds from steps 520 and 525 to step 530, where the processor stores each local ID generated in 525 in a lookup table, translation table, or the like. Those tables have space for each of the corresponding global IDs that are supposed to be accepted from the content management system server when the connection is restored. For example, a translation table, a database record, or some other convenient and logical association, fast and easily with a global ID-once received from a server in a content management system-and a local ID generated in step 525. Any data structure, such as a logical association that allows subsequent processing to match, may be used in place of the lookup table.
The processing flow branches again from step 530, one route handles the global ID and the other route handles the local ID. Therefore, in step 540, the UI module registers listeners for each of the photo and AMN rooms. In this respect, step 540 is similar to step 330 in FIG. However, in parallel, in the 545, the processor module (i) adds the photo to the user's account, (ii) creates an AMN room, and (iii) stores the photo in the AMN room. All of these use local IDs. Adding a photo to your account as described here will display the photo in your account as soon as the photo is generated, without waiting for the server to return a global ID before it can be manipulated. Imply to do.
Similarly, as shown in the room application, the AMN room may be displayed within the user's content management system application, even though the AMN room does not yet "exist" from the perspective of the content management system server. It is important to note here that the AMN room generated by User A is displayed on User A's user device, which means that a similar AMN room has already been created by User M or User N, for example. This is true even if it is generated by sharing its own photo with users A and N or users A and M. Also, depending on the circumstances, another "AMN room" may already exist from the perspective of the content management system server. In other words, parallel AMN rooms can appear on each of User A's, User M's, and User N's user devices. However, only one of them will be recognized or recognized by the content management system server and will eventually be assigned a global ID.
The process goes from step 540 to step 550, where the delta thread of the user device's processor module accepts global IDs for each of the photo and AMN rooms and associates them with their corresponding local IDs in the lookup table. For example, each local ID in the lookup table is associated with a corresponding global ID. This can be achieved, for example, by including the local ID and references to it when the user device requests a global ID. As a result, when the global ID is returned from the server, it is known which local ID it corresponds to. It also prevents the user device from being incorrectly assigned multiple global IDs if it repeatedly resends the same request in step 520 and does not receive a response from the server. This can occur, for example, when a network delay occurs or a user device crash occurs and the request is retransmitted by the user device from the cache or the like after the crash. Alternatively, for example, the global ID request sent to the server (in step 520) may include an action or instruction number or other unique identifier so that the server can eliminate duplicate requests.
Similarly, on the right side of FIG. 5, the process flow goes from step 545 to step 555, where the user device uses the photo ID, room ID, or any other appropriate local ID to use the photo and Refers to all operations in the operation queue including rooms. This means that User A can operate, move, and continue to interact with both the photo and the newly created room as long as he wishes. All interactions involving a photo, such as adding a message to the photo or activating a "like" indicator, or any other interaction, such as sharing a photo with someone who is not a member of the room. Sharing is referenced by the user device using the photo's local ID. Similarly, if the user now decides to add additional photos to Room AMN, whether or not they have already been uploaded to their account, those photos do not yet have a local ID. If so, all of those photos will be given a local ID, and those photos will be associated with the room AMN using the local room ID of the room assigned in step 525. Therefore, depending on the length of time the user device is not connected, how many objects will be created and how many instructions will be queued that require interaction with those objects, all of which will be queued. It is easy to imagine what would be done using the only available ID, the local ID assigned in step 525.
The process flow was reintegrated in steps 550 and 555 through 560, where the processor module now receives the global ID in step 550, so replace each local ID of the operation in the queue with the corresponding global ID, these Push the global ID to the UI as long as each of the items has a registered listener in the UI. However, as mentioned above, if the processor module accepts a global ID without a registered listener, it pushes that global ID to the UI module (since the item it identifies is not expected to be visible to the user). Therefore, in various exemplary embodiments, it will not be pushed into the UI. Thus, content items that appear in user A's account, content items that are copied into the room and associated with the room, and any of the above, were previously only visible on the user device by local ID. All local IDs used to reference such content items are now processed so that their local IDs are replaced by the newly obtained global IDs, so that the local state of the user device is on the server. Can be synchronized with the state.
The processing flow proceeds from step 560 to step 570. Here, the process is whether the user has added more photos to their account or requested other sharing (ie, adding content items or adding content to or queuing added rooms or rooms). Are there any additional instructions?). If YES, the process goes back to step 510, where in the case of a photo, the photo is uploaded if it is not yet part of the user's account, and in the case of sharing, sharing with other users is noted. , The rooms that need to be created as a result of their sharing are generated. If no in 570, the processing flow ends.
Note that the processing flow in FIG. 5 is merely an explanation and is equivalently applied to any content item, data structure, message or interaction with it, which can be assigned an ID number in the content management system. I will do it.
FIG. 6 shows an exemplary system that follows various embodiments. In certain embodiments, the system 600 of FIG. 6 may be substantially similar to the system 100 of FIG. 1 except that the elements of the system 100 are represented at a finer level (eg, modules, applications, etc.).
In certain embodiments, the user device 102 is a content item 110a and 110b (collectively 110) stored locally within the content item systems 108a and 108b (collectively 108) on the user device 102, and / or content management. Content items, such as those stored separately on system 104 (eg, data store 118), can be used to generate, access, modify, and manage. For example, if the user device 102a can access the content item 110b that is stored separately in the data store 118 of the content management system 104 and stores the content item 110b locally in the content item system 108a on the user device 102a. It may not be there. Continuing in this example, the user device 102a temporarily stores the content item 110b locally in the cache on the user device 102a to generate revisions of the content item 110b, and the version of the content item 110b is It can be communicated and stored in the data store 118 of the content management system 104. Optionally, a local copy of content item 110a can be stored on user device 102a. In certain embodiments, the data store 118 may include one or more collections 132 of content items. For example, collection 132 may contain one or more content items that have similar attributes (eg, metadata) and / or contain similar content.
In certain embodiments, the user device 102 may include cameras 138 (eg, 138a and 138b) for capturing and recording digital images and / or video. User device 102 may acquire, record and / or store content items such as images using camera 138. For example, camera 138 may capture and record an image and store the image with metadata. Metadata may include, but is not limited to, the following generation time stamps, user location, orientation, rotation, title and / or any other attributes or data related to the captured image. The metadata value, as attribute 112, accumulates name / value pairs, tag value pairs, and / or any other method or combination of these, and associates the metadata with the content item of the metadata. Easily identify the type. In certain embodiments, attribute 112 is, but is not limited to, Exchangeable Image File Format (Exif), JPEG File Interchange Format. It can be a set of tags and values defined by a particular standard, including (Jfif) and / or other standards.
In certain embodiments, the user device 102 may include a time standardization module 146 and the content management system 104 may include a time standardization module 148. The time standardization module 146 (eg, 146a and 146b) can be used to standardize the date and time accumulated with the content item. The time standardization module 146, the corresponding time standardization module 148 and / or any combination thereof is used to standardize the date and time of the accumulated content item. Standardized dates and times are used to sort, group, perform comparisons, perform basic formulas, and / or cluster content items.
In certain embodiments, the user device 102 may include an organization module 136 and the content management system 104 may include an organization module 140. Organizing modules 136 (eg 136a and 136b) organize content items into clusters and collections of content items, organize content items, and provide sampling of content items for display in the user interface. And / or can be used to search for organized content items for display. The organization module 136 can use any clustering algorithm. The organization module 136 can be used to identify similar content items for the cluster to organize the content items for display of the user interface of the user device 102 and the content items of the content management system 104. .. Similarity rules can be defined to generate one or more numerical representations that embody the similarity information between each content item that follows various similarity rules. The organization module 136 may use a numerical representation as a reference for similarity between content items to cluster the content items.
In certain embodiments, content items can be organized into clusters to assist in the search for similar content in response to search requests. For example, the organization module 136a can identify that two images are similar and can group these images together into one cluster. The organization module 136a may process content items independently and / or in collaboration with the corresponding organization module (eg 140 and / or 136b) to determine the cluster. In certain embodiments, the organization module 136a may provide only the clusters identified as the corresponding organization modules (eg 140 and / or 136b) for display. Continuing this example, the processing of the content item to determine the cluster can be an iterative process that can be performed when receiving a new content item and / or a new rule of similarity.
In certain embodiments, the user device 102a may include a classification module 150a, the user device 102b may include a classification module 150b (classification modules are collectively referred to as 150), and are these classification modules used independently? Classify content items, modify content items, and / or classify images by using in combination with the classification module 152 included in the content management system 104, and / or by making any combination thereof. You may. For example, classification modules 150 and / or 152 can be used to determine if an image contains text and, if so, the type of text that accumulates. Content item modifications may modify the content item, perform further conversions, and / or crop the content item in order to improve the display of the content item (correct the display of text in the image).
In certain embodiments, the user device 102a may include a search module 142a, while the user device 102b may include a search module 142b, which may also be referred to as the search module 142. The content management system 104 may provide the corresponding search module 144. Search modules 142 and 144 may be capable of supporting the search for content items located on both the user device 102 and / or the content management system 104. Search requests requesting one or more content items may be received by search modules 142 and / or 144. In certain embodiments, the search may be processed by searching for the metadata and / or attributes assigned to the content item when providing the management service. For example, cluster markers accumulated with content items can be used to discover content items by date. In this particular scenario, the cluster marker may indicate the approximate time, average time of the content item accumulated with the cluster marker, which searches for clusters of content with the particular cluster marker and returns search results. Can be used to increase speed.
The content item 110 managed by the content management system 104 can be stored locally in the content item system 108 of each user device 102 and / or separately in the data store 118 of the content management system 104 (eg, data store 118). Content items in 134) can be. The content management system 104 may provide a synchronization process of managed content items. Attributes 112a and 112b (112 in total) or other metadata can also be accumulated with content item 110. For example, certain attributes may be accumulated with the content item to track the content item stored locally on the user device 102 managed and / or synchronized by the content management system 104. In certain embodiments, the attribute 112 is implemented using an extended attribute, a resource fork, or any other implementation capable of accumulating metadata with content items that are not interpreted by the content item system, such as the content item system 108. obtain. In particular, attributes 112a and 112b can be content identifiers for content items. For example, a content identifier can be a unique or nearly unique identifier (eg, a number or string) that identifies a content item. Content items can be tracked by accumulating content identifiers along with the content items. For example, if the user moves the content item elsewhere in the content item system 108 hierarchy and / or the user modifies the content item, the content item is still identified in the content item system 108 on user device 102. It is possible. Any changes or modifications to the content item identified by the content identifier are for the synchronization and / or version control service provided by the content management system 104.
Stand-alone content management applications 114a and 114b (114 combined), client applications, and / or third-party applications run on user devices 102a and 102b, respectively, and a user interface in which the user interacts with the content management system 104. I will provide a. The content management application 114 may externally provide functionality and accessible modules for the user device 102, which are provided with the content management interface module 154. The web browsers 116a and 116b (116 in total) are provided externally with the content management interface module 154 and are used to display the web page front end of a client application that may provide the functionality of the content management 104.
Content management system 104 allows users to store content using authenticated accounts and also performs management tasks such as searching, modifying, browsing, synchronizing and / or sharing content with other accounts. Various embodiments of the content management system 104 include a content management interface module 154, an account management module 120, a synchronization module 122, a collection module 124, a shared module 126, a file system abstraction 128, a data store 118, and an organizing module 140. It may have elements that include, but is not limited to these. The content management interface module 154 may provide the server-side or back-end functions / performance of the content management system 104 to the outside. For example, the corresponding user interface of the user device 102 (eg, a stand-alone application, a client application, etc.) is performed using the content management interface module 154, allowing the user to perform the functions provided by the content management system 104. obtain.
The user interface displayed on the user device 102 can be used by using the account management module 120 to generate an account and / or authenticate the user to use the account. The account management module 120 may provide the ability to authenticate the use of the account by the user and / or the user device 102 using a username / password, a device identifier, and / or any other authentication method. Account information 130 may be managed for the account within the data store 118. Account information includes personal information (eg, email address or username), account management information (eg, account types such as "free" and "paid"), usage information (content item edit history), and permitted. It may include, but is not limited to, the largest storage space, used storage space, content storage location, security settings, personal configuration settings, content shared data, and the like. The amount of storage space in the content management system 104 can be reserved, distributed, secured, stored, and / or accessed by an authenticated account. An account shares content item 134 and / or content item 110 with and / or content item 134 and / or content item 110 from another account in order to access content item 134 and / or content item 110 for that account in the data store 118. Can be used to make it accessible from. In certain embodiments, the account management module 120 may interact with any number of other modules in the content management system 104.
In certain embodiments, the account of the content management system 104 can be used to store content such as documents, text items, audio items, video items, etc. from one or more user devices 102 authenticated by the account. Content can also include various types of collections that behave differently or use other mechanisms that group content items together. For example, an account may include a public collection made accessible to any user. In certain embodiments, public collections can be assigned to web-accessible addresses. Links to addresses accessible on the web can be used to access the contents of published folders. In another example, the account may include a photo collection that may store photos and / or videos, and may provide specific attributes and actions tailored to the purpose of the photos and / or videos. Accounts may also include audio collections that provide the ability to play audio items and perform other audio-related actions. Accounts may also include collections of specific purpose. Accounts can also be linked to multiple user accounts and include shared or group collections available from these accounts. In certain embodiments, access to the shared collection can be different for different users who can access the shared collection.
Content item 110 and / or content item 134 may be stored in data store 118. In certain embodiments, the data store 118 can be a storage device, a plurality of storage devices, or a server. Alternatively, the data store 118 can be a cloud storage provider or network storage accessible via one or more communication networks. The content management system 104 uses the content item system abstraction 128 (eg, the content item system database abstraction layer) to hide complexity and details from the user device 102 and is accumulated by the content management system 104. It may prevent the user device 102 from having to know exactly where the content item is. Embodiments may hierarchically accumulate content items in the same collection as they appear on user device 102. Alternatively, the content management system 104 may accumulate content items in various orders, arrangements, and / or hierarchies. The content management system 140 may store content items in network accessible storage (SAN) devices, redundant array of inexpensive disks (RAID), and the like. The content management system 104 may store content items using one or more partition types such as FAT, FAT32, NTFS, EXT2, EXT3, EXT4, ReiserFS, BTRFS and the like.
Data store 118 may also store metadata representing content items, content item types, and content item relationships with various accounts, folders, collections, or groups. Metadata for this content item can be stored as part of the content item and / or separately. Metadata can be stored in object-oriented databases, relational databases, content item systems, or any other collection of data. In certain embodiments, each content item stored in data store 118 may be assigned a unique identifier throughout the system.
In certain embodiments, the data store 118 may reduce the amount of storage space required by identifying content item duplications and content item chunks. Instead of accumulating multiple copies, the data store 118 may accumulate one copy of content item 134 and use pointers and other mechanisms to connect the one copy to the duplicate. Similarly, data store 118 stores content item 134 more efficiently, as well as content item version management that tracks changes in content items, different versions of content items (including branching of the version tree), and change history. By using it, it may provide the functionality of an Undo operation. The change history can include a set of changes when it was applied to the original content item version and when the changed content item version was generated.
The content management system 104 may be configured to support automatic synchronization of content from one or more user devices 102. The synchronization process can be platform independent. That is, the content can be synchronized across a plurality of user devices 102 of different types, functions, operating systems, and the like. For example, the user device 102a may include client software that synchronizes the content in the content item system 108 of the user device 102 with the content associated with the user account via the synchronization module 122 of the content management system 104. In some cases, the Client Software may make any changes to the content within the specified collection and its sub-collections, such as new, deleted, modified, copied or moved content items and folders. Can be synchronized with. In one example of client software that combines with an existing content management system, the user can interact directly with the content in the local folder, while a background process monitors the local content for changes and makes changes to the content management system 104. Synchronize. In one embodiment, the background process identifies the updated content in the content management system 104 and synchronizes the changes to the local collection. The client software may provide notification of the operation of the synchronization process and may provide a display of the content status directly within the application of the content management system. In certain embodiments, the user device 102 may not have an available network connection. In this scenario, the client software monitors the linked collection for content item changes and queues these changes for later synchronization to the content management system 104 when a network connection is available. Can be put in. Similarly, the user
The user may also view or manipulate the content through the web interface generated and provided by the content management interface module 154. For example, the user may navigate within a web browser to the web address provided by the content management system 104. Changes or updates to the content of the data store 118 made through the web interface, such as uploading a new version of the content item, may be propagated back to the other user device 102 associated with the user account. For example, each of the plurality of user devices 102 is associated with one account using its client software, and content items within the account can be synchronized with each of the user devices 102.
The content management system 104 may include a sharing module 126 for managing public or private sharing of content and / or a collection of content. The shared module 126 may manage sharing independently or in cooperation with the corresponding shared module 152a on the user device 102a and the corresponding shared module 152b on the user device 102b (together, the shared module 152). Sharing content by public may include making content items and / or collections accessible from any device in network communication using the content management system 104. Private content sharing may include linking content items and / or collections in data store 118 with two or more user accounts, making each user account accessible to the content. This sharing can be platform independent. That is, the content can be shared across a plurality of user devices 102 of different types, functions, operating systems, and the like. For example, one or more shared links may be provided to a user or a user's contact to access a shared content item. Content can also be shared across different user account types. In particular, the shared module 126 can be used with the collection module 124 to share a virtual collection with other users or user accounts. A virtual collection can be a collection of content identifiers that can be stored at various locations within the content item system 108 of user device 102 and / or separately at the content management system 104.
In certain embodiments, a virtual collection for an account using a content management system may correspond to a collection of one or more identifiers for a content item (eg, identify a content item in storage). The virtual collection is selected from existing content items stored and / or managed by the content management system using the collection module 124 to associate the virtual collection with the existing content items in the data storage (eg, storage location, It can be generated by associating a content identifier, or the address of a stored content item). By associating an existing content item with a virtual collection, the content item accumulates the content item elsewhere in the data storage (eg, copy and paste the content item into a directory) in order to put the content item in the collection. ) Can be specified as part of a virtual collection that does not need to be.
In certain embodiments, the content management system 104 may be configured to manage a content directory or database table / entry for a content item, where each entry or row locates each content item in the data store 118. In certain embodiments, a unique or nearly unique identifier may be stored for each content item stored in data store 118.
In certain embodiments, metadata may be accumulated for each content item. For example, the metadata may include the path of the content used to identify the content item. The content path may include the name of the content item and the hierarchy of the content item associated with the content item (eg, the path to the local accumulation in the user device 102). The content management system 104 may use the content path to display content items in the appropriate content item hierarchy in a user interface with a traditional hierarchical view. A pointer to the content that locates the content item in the data store 118 can also be accumulated with the content identifier. For example, a content pointer may include the exact storage address of a content item in memory. In certain embodiments, the content pointers may point to multiple locations, each containing a portion of the content item.
In addition to the content path and content pointer, a row in the database table of the content item entry / content item database may contain a user account identifier that identifies the user account that has access to the content item. In certain embodiments, multiple user account identifiers can be associated with a single content entry that identifies that a content item has been shared across multiple user accounts.
To share a content item privately, the sharing module 126 may be configured to add a user account identifier to the content entry or database table row associated with the content item, thereby adding it to the content item. Register the access of the user account. The sharing module 126 may also be configured to remove the user account identifier from the content entry or row in the database table to restrict access of the user account to the content item. Shared module 126 can also be used to add or remove user accounts from database tables for virtual collections.
When sharing content by publishing, the sharing module 126 provides a custom network address, such as a uniform resource locator (URL), that allows any browser to access the content management system 104 without any authentication. It can be configured to produce. To achieve this, the sharing module 126 may be configured to include content identification data in the generated URL. This content identification data may be used later to properly identify and reply to the requested content item. For example, the sharing module 126 may be configured to include a user account identifier and content path in the generated URL. In selecting a URL, the content identifier data contained in the URL can receive the content identifier data, identify the appropriate content entry, and return the content item associated with this content entry, a content management system. Can be sent to 104.
To share the virtual collection by publishing, the sharing module 126 allows a custom network address, such as a uniform resource locator (URL), to allow any browser to access the content management system 100 without any authentication. Can be configured to produce. To achieve this, the sharing module 126 may be configured to include collection identification data in the generated URL. This collection identification data may be used later to properly identify and reply to the requested content item. For example, the sharing module 126 may be configured to include a user account identifier and a collection identifier in the generated URL. When selecting a URL, the content identification data contained in the URL may be sent to the content management system 104, which uses the received content identification data to make the appropriate content entry or database row. You may specify and return the content item associated with this content entry or row in the database.
In addition to URL generation, the sharing module 126 may also be configured to record that a URL to a content item has been generated. In certain embodiments, the content entry associated with the content item may include a URL flag indicating whether a URL to the content item has been generated. For example, the URL flag can be a binary that is initially set to 0 or "false", indicating that a URL to the content item has not been generated. The sharing module 126 may be configured to change the value of the flag to 1 or "true" after the URL to the content item has been generated.
In certain embodiments, the shared module 126 may also be configured to deactivate the generated URL. For example, each content entry may also include a URL activation flag that indicates whether the content should be returned in response to a request from the generated URL. For example, the sharing module 126 may be configured to return only the content items requested by the link generated when the URL activation flag is set to 1 or "true". Changing the value or binary of the URL activation flag can easily limit access to the content item or collection from which the URL was generated. This allows users to restrict access to shared content without having to move content items or delete generated URLs. Similarly, the shared module 126 may reactivate the URL by changing the value of the URL activation flag to 1 or "true" again. Therefore, the user can easily regain access to the content item without having to generate a new URL.
Illustrative system In an exemplary embodiment of the invention, a particular embodiment using any suitable programming language such as C, C ++, Java®, JavaScript®, Python, Ruby, CoffeeScript, assembly language, etc. Routines can be implemented. Different programming techniques such as procedural or object-oriented can be used. Routines can be executed on one processing device or multiple processors. Steps, operations, and computer processes can be represented in a particular order, which can be changed in different particular embodiments. In certain embodiments, the plurality of steps presented herein in succession can be performed simultaneously.
Certain embodiments may be implemented on a computer-readable storage device or non-transitory computer-readable medium for use with an instruction execution system, device, system or device. Certain embodiments may be implemented in the form of control logic in software or hardware or a combination of both. This control logic may be operational to execute what is described in a particular embodiment when executed on one or more processors.
Specific embodiments use programmed general purpose digital computers for application-specific integrated circuits, programmable logic devices, FPGAs (field programmable gate arrays), optical, chemical, bio, quantum or nano-processing systems, components and It can be implemented using a mechanism. In general, the functionality of a particular embodiment can be achieved by any means known in the art. Decentralized, networked systems, components, and / or circuits can be used. Communication or transmission of data may be by wire, wireless or any other means.
One or more of the elements illustrated in the examples / figures are treated as useful according to a particular application, in a more fragmented or integrated manner, or as having been removed or in some cases not working. Can be implemented. It may be within the scope of the idea and scope to implement a program or code that can be stored on a machine-readable medium such as a storage device and have the computer perform any of the methods described above.
As used herein and throughout the claims below, "a", "an" and "the" include multiple references unless the context explicitly states. Also, as used herein and in all parts of the following claims, the meaning of "in" includes "in" and "on" unless the context explicitly states.
Although methods of providing the user with a user interface that allows for a sufficient number of interaction features in various modes of operation have been described, many do not deviate from the scope and ideas of the invention for such. It should be understood that changes can be made. Substantial changes, unknown or later devised from the subject matter claimed by those skilled in the art are assumed to be equivalent to the scope of the claims. Thus, substitutes currently apparent to those skilled in the art or those later known to those skilled in the art can be defined as being within the scope of the defined elements. The described embodiments of the present invention are presented for purposes of illustration, but not limitation.
6 sheets
Sheet 1 Sheet 2 Sheet 3 Sheet 4 Sheet 5 Sheet 6
Every citation, both ways
| Document | Relation | Office |
|---|---|---|
| US07437405B1 | Cites | United States of America |
| JP2011054092A | Cites | Japan |
| US20030117434A1 | Cites | United States of America |
30 members in 5 offices
Priority claims24
| Document | Office | Kind | Date |
|---|---|---|---|
| 201361920730 | United States of America | P | |
| 201361920730 | United States of America | P | |
| 61920730 | United States of America | – | |
| 201461945814 | United States of America | P | |
| 201461945814 | United States of America | P | |
| 201461945817 | United States of America | P | |
| 201461945817 | United States of America | P | |
| 61945814 | United States of America | – | |
| 61945817 | United States of America | – | |
| 14247607 | United States of America | – | |
| 201414247607 | United States of America | A | |
| 201414247607 | United States of America | A | |
| 2014072115 | United States of America | W | |
| 2014072115 | United States of America | W | |
| 14247607 | – | – | – |
| 61920730 | – | – | – |
| 61945814 | – | – | – |
| 61945817 | – | – | – |
| US201361920730P | – | – | – |
| US2014072115 | – | – | – |
| US201414247607 | – | – | – |
| US201461945814P | – | – | – |
| US201461945817P | – | – | – |
| WO2014US72115 | – | – | – |
Members30
| Document | Office | Kind | |
|---|---|---|---|
| US2015177938A1 | United States of America | A1 | |
| US2015180914A1 | United States of America | A1 | |
| US2015180980A1 | United States of America | A1 | |
| US2015180984A1 | United States of America | A1 | |
| WO2015099833A1 | World Intellectual Property Organization (WIPO) | A1 | |
| WO2015100305A1 | World Intellectual Property Organization (WIPO) | A1 | |
| WO2015100307A1 | World Intellectual Property Organization (WIPO) | A1 | |
| WO2015099833A9 | World Intellectual Property Organization (WIPO) | A9 | |
| AU2014369911A1 | Australia | A1 | |
| AU2014370005A1 | Australia | A1 | |
| AU2014370399A1 | Australia | A1 | |
| US9423922B2 | United States of America | B2 | |
| JP2016529634A | Japan | A | |
| JP2016533609A | Japan | A | |
| EP3087485A1 | European Patent Office (EPO) | A1 | |
| EP3087486A1 | European Patent Office (EPO) | A1 | |
| EP3087487A1 | European Patent Office (EPO) | A1 | |
| US2016323332A1 | United States of America | A1 | |
| US9544373B2 | United States of America | B2 | |
| JP2017502436A | Japan | A | |
| US2017048332A1 | United States of America | A1 | |
| AU2014370005B2 | Australia | B2 | |
| AU2014370399B2 | Australia | B2 | |
| JP6171104B2This record | Japan | B2 | |
| AU2014369911B2 | Australia | B2 | |
| JP6243038B2 | Japan | B2 | |
| JP6311030B2 | Japan | B2 | |
| US9961149B2 | United States of America | B2 | |
| US10067652B2 | United States of America | B2 | |
| US10200421B2 | United States of America | B2 |
14 legal events, as the office reported them to INPADOC
Over the term
Point at a mark for the eventEvents
| Event | Code | |
|---|---|---|
| Receipt of annual feesJAPANESE INTERMEDIATE CODE: R250R250 | R250 | |
| Receipt of annual feesJAPANESE INTERMEDIATE CODE: R250R250 | R250 | |
| Receipt of annual feesJAPANESE INTERMEDIATE CODE: R250R250 | R250 | |
| Receipt of annual feesJAPANESE INTERMEDIATE CODE: R250R250 | R250 | |
| Receipt of annual feesJAPANESE INTERMEDIATE CODE: R250R250 | R250 | |
| Receipt of annual feesJAPANESE INTERMEDIATE CODE: R250R250 | R250 | |
| Certificate of patent or registration of utility modelJAPANESE INTERMEDIATE CODE: R150R150 | R150 | |
| First payment of annual fees (during grant procedure)JAPANESE INTERMEDIATE CODE: A61A61 | A61 | |
| Written decision to grant a patent or to grant a registration (utility model)JAPANESE INTERMEDIATE CODE: A01A01 | A01 | |
| Decision of grant or rejection writtenTRDD | TRDD | |
| Request for written amendment filedJAPANESE INTERMEDIATE CODE: A523A521 | A521 | |
| Notification of reasons for refusalJAPANESE INTERMEDIATE CODE: A131A131 | A131 | |
| Request for written amendment filedJAPANESE INTERMEDIATE CODE: A523A521 | A521 | |
| Written request for application examinationJAPANESE INTERMEDIATE CODE: A621A621 | A621 |
Numbers
- Publication
- 6171104
- Publication, DOCDB
- 6171104
- Publication, EPODOC
- JP6171104B
- Application
- 2016546913
- Application, DOCDB
- 2016546913
- Application, EPODOC
- JP20160546913
Titles2
- Japanese
- モバイルデバイス上での、クラウドベースのコンテンツマネージメントシステムへのアクセスの提供
- English
- Providing access to cloud-based content management systems on mobile devices
Classification
- CPC, 3
- G06F16/27
- G06F3/0484
- H04L41/22
- IPC, 2
- G06F13 00
- G06F12 00
