Hci Portals

[Ashely Wolfgram]

Thispage provides information and resources for crowdfunding intermediaries that, pursuant to Title III of the JOBS Act, the SEC's Regulation Crowdfunding and FINRA's rules for funding portals, register with the SEC as funding portals and become funding portal members of FINRA.

If your firm has a change of ownership or control as set forth in Funding Portal Rule 110(a)(4), you must notify FINRA of those changes by filing a continuing membership application for funding portals, known as Form Funding Portal - Continuing Membership Application, located in the Funding Portal Gateway.

FINRA is providing the Written Supervisory Procedures Checklist as an optional guide to assist member firms in fulfilling their regulatory obligations. This tool is provided as a starting point and you must tailor this tool to reflect the size and needs of your firm. Using this tool does not guarantee compliance with or create any safe harbor with respect to FINRA rules, the federal securities laws or state laws, or other applicable federal or state regulatory requirements. This tool does not create any new legal or regulatory obligations for firms or other entities.

Requests made via portal interfaces generally involve user interaction, and dialogs that can stay open for a long time. Therefore portal APIs don't just use async method calls (which time out after at most 25 seconds), but instead return results via a Response signal on Request objects.

Portal APIs don't use properties very much. This is partially because we need to be careful about the flow of information, and partially because it would be unexpected to have a dialog appear when you just set a property.

The general flow of the portal API is that the application makes a portal request, the portal replies to that method call with a handle (i.e. object path) to Request object that corresponds to the request. The object is exported on the bus and stays alive as long as the user interaction lasts. When the user interaction is over, the portal sends a Response signal back to the application with the results from the interaction, if any.

To avoid a race condition between the caller subscribing to the signal after receiving the reply for the method call and the signal getting emitted, a convention for Request object paths has been established that allows the caller to subscribe to the signal before making the method call.

Some portal requests are connected to each other and need to be used in sequence. The pattern we use in such cases is a Session object. Just like Requests, Sessions are represented by an object path, that is returned by the initial CreateSession call. Subsequent calls take the object path of the session they operate on as an argument.

Most portals interact with the user by showing dialogs. These dialogs should generally be placed on top of the application window that triggered them. To arrange this, the compositor needs to know about the application window. Many portal requests expect a "parent_window" string argument for this reason.

Portal interfaces are available to sandboxed applications with the default filtered session bus access of Flatpak. Unless otherwise specified, they appear under the bus name org.freedesktop.portal.Desktop and the object path /org/freedesktop/portal/desktop on the session bus.

A string that can be shown in the dialog to expain why the information is needed. This should be a complete sentence that explains what the application will do with the returned information, for example: Allows your personal information to be included with recipes you share with your friends.

This interface lets services ask if an application should get access to devices such as microphones, speakers or cameras. Not a portal in the strict sense, since the API is not directly accessible to applications inside the sandbox.

Exported files will be made accessible to the application via a fuse filesystem that gets mounted at /run/user/$UID/doc/. The filesystem gets mounted both outside and inside the sandbox, but the view inside the sandbox is restricted to just those files that the application is allowed to access.

If the as-needed-by-app flag is given, files will only be added to the document store if the application does not already have access to them. For files that are not added to the document store, the doc_ids array will contain an empty string.

If the as-needed-by-app flag is given, file will only be added to the document store if the application does not already have access to it. For file that is not added to the document store, the doc_id will contain an empty string.

The DynamicLauncher portal allows sandboxed (or unsandboxed) applications to install launchers (.desktop files) which have an icon associated with them and which execute a command in the application. The desktop environment would display the launcher to the user in its menu of installed applications. For example this can be used by a sandboxed browser to install web app launchers. The portal also allows apps to uninstall the launchers, launch them, and read the desktop file and icon data for them.

The standard way to install a launcher is to use the PrepareInstall() method which results in a dialog being presented to the user so they can confirm they want to install the launcher. Then, the token returned by PrepareInstall() would be passed to the Install() method to complete the installation.

However, in the rare circumstance that an unsandboxed process such as a system component needs to install a launcher without user interaction, this can be accomplished by using the RequestInstallToken() method and passing the acquired token to Install().

Installs a .desktop launcher and icon into appropriate directories to allow the desktop environment to find them. Please note that this method overwrites any existing launcher with the same id. If you want to present the user with a confirmation dialog in that case, you can check for it using the GetDesktopEntry() method and clean up any state from the previous launcher if you want.

The desktop_file_id must have ".desktop" as a suffix. Except in the special case when the calling process has no associated app ID, desktop_file_id must have the app ID followed by a period as a prefix, regardless of whether the calling process is sandboxed or unsandboxed.

The desktop_entry should be a valid desktop entry file beginning with "[Desktop Entry]", except it should not include Name= or Icon= entries (if present, these will be overwritten by the portal implementation). The Exec= entry will be rewritten to call the sandboxed application e.g. via "flatpak run", if the application is sandboxed.

This method is intended for use only by specific components that have their application ID allowlisted in the portal backend (e.g. GNOME Software and KDE Discover). It is otherwise not guaranteed to work.

The token returned by this method can be used to avoid the need for a confirmation dialog; the token can be passed to the Install() method just as if it were acquired via the PrepareInstall() method.

This method is intended to be called by the application that created the launcher, e.g. a web browser, so it can clean up associated data as part of the uninstallation. Consequently, the proper way for a software center to remove a launcher is by using the APIs provided by the application that installed it. For example, for GNOME Software to remove web launchers created by Epiphany, it would use the org.gnome.Epiphany.WebAppProvider D-Bus interface.

The desktop_file_id must have ".desktop" as a suffix. Except in the special case when the calling process has no associated app ID, desktop_file_id must have the app ID followed by a period as a prefix.

This function returns the contents of the icon specified in the "Icon" key of the desktop file with the name desktop_file_id in icon_v. The icon #GVariant can be passed to g_icon_deserialize() to reconstruct the #GIcon.

Note that the default email client for the host will need to support mailto: URIs following RFC 2368, with "cc", "bcc", "subject" and "body" query keys each corresponding to the email header of the same name, and with each attachment being passed as a "file://" URI as a value in an "attachment" query key.

Each item in the array specifies a single filter to offer to the user. The first string is a user-visible name for the filter. The a(us) specifies a list of filter strings, which can be either a glob-style pattern (indicated by 0) or a mimetype (indicated by 1). Patterns are case-sensitive. To match different capitalizations of, e.g. '*.ico', use a pattern like '*.[iI][cC][oO]'.

Note that filters are purely there to aid the user in making a useful selection. The portal may still allow the user to select files that don't match any filter criteria, and applications must be prepared to handle that.

Request that this filter be set by default at dialog creation. If the filters list is nonempty, it should match a filter in the list to set the default filter from the list. Alternatively, it may be specified when the list is empty to apply the filter unconditionally.

For each element, the first string is an ID that will be returned with the response, the second string is a user-visible label. The a(ss) is the list of choices, each being an ID and a user-visible label. The final string is the initial selection, or "", to let the portal decide which choice will be initially selected. None of the strings, except for the initial selection, should be empty.

3a8082e126