badoo/Chatto

This system is a modular iOS framework for building chat interfaces, consisting of a core library for managing chat state and a UI additions library for rendering message types. It provides infrastructure for displaying text, photo, and compound messages, along with customizable input bars that support camera and photo selection. The architecture emphasizes extensibility through composable components and injectable handlers for keyboard, layout, and gesture interactions.

19 changes.

The Chatto framework and its additions underwent significant project restructuring to improve modularity, build reliability, and Swift 5 compatibility. This period also focused on establishing a robust demo application and expanding unit test coverage across core components, input handling, and message presenters.

30 changes.

The project underwent a significant architectural overhaul to support composable, compound message layouts, introducing new infrastructure for base, text, photo, and compound message types. This period also focused on modularizing the chat controller, input bar, and keyboard handling into injectable collaborators to improve testability and customization. The demo application was extensively restructured to showcase these new capabilities, including pagination, message selection, and complex input interactions.

This change introduces the complete component set for displaying photo messages within the chat, including the model, presenter, view model, and UI views. Users can now view sent and received images with support for transfer progress indicators, placeholder icons, and styled bubbles that adapt to landscape, portrait, or square aspect ratios.

ChattoAdditions/sources/Chat Items/PhotoMessages · high confidence

The ChattoApp demo now includes a new 'Content Aware Input' chat item. This feature provides a custom input view containing a text field, a descriptive label, and a 'Send Message' button. It implements the ChatInputItemProtocol to support expandable states and custom view presentation, allowing users to type and send messages within this specific demo component.

ChattoApp/ChattoApp/Source/Chat Items/Content Aware Input · high confidence

The project now includes dedicated Xcode schemes for the Chatto and ChattoAdditions frameworks, enabling developers to build, test, run, profile, and archive these specific components directly from the IDE. These schemes are configured to target the respective framework products within the Pods project, streamlining the development and debugging workflow for these library components.

ChattoApp/Pods/Pods.xcodeproj/xcshareddata · high confidence

A new Xcode workspace file (contents.xcworkspacedata) has been added to the .swiftpm directory. This file configures the workspace to reference the package itself, enabling direct opening and editing of the Swift Package Manager project within Xcode.

.swiftpm · high confidence

A new \scripts/test.sh\ script has been added to streamline the testing process for the Chatto project. This script allows users to run tests for specific components (Chatto, ChattoAdditions, or ChattoApp) by passing a command-line argument. It automatically configures the correct workspace and scheme, targets the iOS Simulator (iPhone 15), and pipes the output through xcpretty for cleaner reporting. The script also enforces \pipefail\ to ensure that errors in any part of the build/test pipeline are correctly reported.

scripts · high confidence

The chat interface now displays visual status indicators for messages in transit or failed to send. Users will see 'Sending...' while a message is being transmitted and 'Sending failed' in red text if the transmission fails. This is implemented via a new SendingStatusPresenter and corresponding cell that renders these localized status strings within the chat flow.

ChattoApp/ChattoApp/Source/Chat Items/Sending status · high confidence

The ChattoApp demo now includes a set of new files under the Compound Messages directory that demonstrate how to render compound chat items. This includes a new model (DemoCompoundMessageModel) and view-model builder to support messages composed of multiple parts, along with specific content factories for displaying dates (with borders and safe-area insets), images, secondary text, and invisible splitters. Additionally, a new emoji decoration view factory allows attaching emoji overlays to these compound messages, providing a complete example of complex, multi-element message layouts in the demo application.

ChattoApp/ChattoApp/Source/Chat Items/Compound Messages · high confidence

The ChattoApp demo now features a new composable message system within the Base Message folder, introducing components like AsyncImageItem, CompoundItem, and MessageBubbleView to allow flexible, nested message layouts. It also adds support for photo messages with a dedicated DemoPhotoMessageModel and ViewModel that simulates asynchronous image loading and transfer progress. Additionally, the demo includes a DemoMessageInteractionHandler that exposes interaction points such as double-tap and long-press, and configures avatar styles to display avatars for both incoming and outgoing messages.

ChattoApp/ChattoApp/Source/Chat Items/Base Message · high confidence

The demo application now includes specific \DemoTextMessageModel\ and \DemoTextMessageViewModel\ classes along with a \DemoTextMessageViewModelBuilder\. This builder allows the demo to construct text message view models with a configurable image provider (defaulting to a user avatar), enabling the demo to showcase text message rendering with avatar images independently of the core library's default behavior.

ChattoApp/ChattoApp/Source/Chat Items/Text Messages · high confidence

The ChattoApp Xcode project has been reorganized to include new demo examples for compound messages, composable items, and asynchronous avatar loading. This update adds specific view controllers and factories (such as DemoCompoundMessageModel and AsyncAvatarLoadingViewController) to the build, reflecting the addition of these new demonstration capabilities within the sample application.

ChattoApp/ChattoApp.xcodeproj · high confidence

This change establishes the foundational structure for the ChattoApp demo application. It introduces the standard iOS application configuration, including the Info.plist with required device capabilities and usage descriptions, a LaunchScreen storyboard for the app startup view, and an asset catalog containing the AppIcon set for iPhone and iPad, along with specific UI assets such as bubble tail borders, test images, and reply/user avatar graphics.

ChattoApp/ChattoApp · high confidence

The ChattoApp workspace is initialized with standard Xcode configuration files. This includes the workspace data linking the main project and CocoaPods, IDE template macros for automatic MIT license headers in new files, workspace checks to track build system changes, and settings to disable preview features.

ChattoApp/ChattoApp.xcworkspace · high confidence

This change introduces the foundational components for the chat message UI within the ChattoAdditions framework. It adds the \BaseMessageModel\ and \MessageModelProtocol\ to define message data structures, including status and reply capabilities. The \BaseMessagePresenter\ is added to handle the logic for configuring cells and managing interactions like taps and long presses. A new \BaseMessageViewModel\ and \MessageViewModelProtocol\ provide the view layer with formatted data such as dates and status indicators. Finally, the \BaseMessageCollectionViewCell\ and its associated styling (\BaseMessageCollectionViewCellDefaultStyle\) and layout definitions are introduced, providing a reusable base cell for displaying messages with support for avatars, failed icons, and selection states.

ChattoAdditions/sources/Chat Items/BaseMessage · high confidence

The chat view now supports compound messages, allowing a single chat item to display multiple distinct content types (such as text, images, or attachments) within one cohesive bubble. This change introduces the \CompoundMessagePresenter\ and its builder, which manage the lifecycle of multiple internal content presenters and decoration views, enabling complex, multi-element message compositions to be rendered and updated efficiently in the chat interface.

ChattoAdditions/sources/Chat Items/CompoundMessage · high confidence

This change introduces a new composable architecture for chat items within the ChattoAdditions framework. It adds a suite of new components including a Binder for binding view models to views, a ViewAssembler and LayoutAssembler for constructing view hierarchies and applying layouts, and a FactoryAggregate for creating views, view models, and layout providers. The diff also adds supporting protocols and types such as BindingKey, MessageViewHierarchy, and various layout-related protocols (LayoutProviderProtocol, LayoutModel, SizeContainer) to enable a more modular and type-safe approach to building chat cell content.

ChattoAdditions/sources/Chat Items/Composable · high confidence

The chat input area has been refactored into a new, modular \ChatInputBar\ component located in \ChattoAdditions/sources/Input\. This change introduces a dedicated XIB-based UI (\ChatInputBar.xib\) that supports configurable appearance settings via \ChatInputBarAppearance\, allowing customization of the send button, tab bar, and text input styles. The update also adds \ExpandableTextView\ for dynamic text resizing and \ExpandableChatInputBarPresenter\ to handle expanded input views, enabling a more flexible and visually customizable chat input experience.

ChattoAdditions/sources/Input · high confidence

This change adds several new source files to the Chatto and ChattoAdditions frameworks, introducing core infrastructure and specific message types. It includes a \ChatItemCompanionCollection\ for efficient item indexing, a \SerialTaskQueue\ for managing asynchronous tasks, and an \Info.plist\ setting the framework version to 4.1.0. In the additions layer, it introduces a complete implementation for text messages (including models, view models, presenters, and UI views) and a new compound message system featuring \CompoundBubbleView\, layout providers, and decoration view factories, alongside updated decoration attribute structures.

(repo-wide) · high confidence

Users will now see date-based separators (e.g., "Monday, Mar 7 2016") within the chat interface to group messages by day. This change introduces the \TimeSeparatorModel\, \TimeSeparatorPresenter\, and \TimeSeparatorCollectionViewCell\ components, which handle the data, presentation logic, and visual rendering of these separators respectively. The presenter registers the cell with the collection view and configures it to display the formatted date string, ensuring a consistent visual break between message groups.

ChattoApp/ChattoApp/Source/Time Separator · high confidence

This change introduces a new \Observable\<T\>\ class in \Chatto/sources/Utils/Observable.swift\ that provides a thread-safe, observer-pattern wrapper for values, allowing clients to register and remove observers. For iOS 13 and later, this observable exposes a \values\ property that maps its changes to an \AsyncStream\, enabling modern async/await consumption patterns. Additionally, \Chatto/sources/Utils/Utils.swift\ adds convenience extensions for \UIScrollView\ and \UICollectionView\ to simplify configuration of content inset adjustments, scroll indicator insets, and prefetching behavior within view controllers.

Chatto/sources/Utils · high confidence

This change introduces the core implementation for the camera and photo selection features in the chat input bar. It adds a new \Camera\ subdirectory containing \LiveCameraCell\ and \LiveCameraCellPresenter\ to handle the live camera preview UI and session management, alongside \DeviceImagePicker\ and \PhotosInputCameraPicker\ to manage the system camera picker and image capture flow. It also adds \PhotosInputCell\ and \PhotosInputDataProvider\ to display and load images from the user's photo library, supported by new asset catalog images for camera and lock icons.

ChattoAdditions/sources/Input/Photos · high confidence

This change introduces a new \NewChatMessageCollectionAdapter\ and supporting components (\ChatCollectionViewLayoutModelFactory\, \CollectionUpdateProvider\) within the \Chatto/sources/ChatController/ChatMessages/New\ directory. The new adapter manages the \UICollectionView\ data source and delegate methods for chat messages, handling cell presentation, scrolling, and update coalescing. The \ChatCollectionViewLayoutModelFactory\ calculates layout models, including cell heights and margins, supporting both main-thread and background height calculations. The \CollectionUpdateProvider\ handles the transformation of chat items into decorated companions and manages presenter updates. Configuration options like \fastUpdates\, \coalesceUpdates\, and \isRegisteringPresentersAutomatically\ are exposed via \NewChatMessageCollectionAdapterConfiguration\.

Chatto/sources/ChatController/ChatMessages/New · high confidence

This change introduces a new set of foundational utilities in the ChattoAdditions common module to support consistent layout and device handling. It adds alignment enums (Horizontal/VerticalAlignment) and geometry extensions (CGRect, CGSize, CGPoint, CGFloat) for precise rounding, offsetting, and clamping, enabling more predictable view sizing. A new ScreenMetrics system detects specific iPhone and iPad models (including iPhone 12 Pro support) and provides default keyboard heights for portrait and landscape orientations, with a fallback to portrait mode when device orientation is unknown. Additional utilities include a generic Cache struct, animation helpers for fade-ins and transaction control, image masking, color blending, and resource bundle loading for Swift Package Manager compatibility.

ChattoAdditions/sources/Common · high confidence

The ChattoApp demo has been restructured to include a new entry point and navigation flow, featuring a main examples list that showcases various chat configurations such as empty chats, large message sets, compound messages, and async avatar loading. A key addition is the \SlidingDataSource\, which enables efficient pagination and windowing for large lists, allowing users to load previous or next pages of items dynamically. The demo also introduces a \MessagesSelectorProtocol\ and its \BaseMessagesSelector\ implementation, providing a standardized way to handle message selection states (select/deselect) within the chat interface. Additionally, the app now includes specific examples for testing item reloading, updating item types, and handling tab bar visibility states.

ChattoApp/ChattoApp/Source · high confidence

The Chatto project now includes a dedicated Xcode workspace (Chatto.xcworkspace) that groups the Chatto and ChattoAdditions projects together. This change introduces shared build, test, and launch schemes for both frameworks, enabling unified development workflows. It also adds IDE template macros for consistent file headers and workspace check files to manage Xcode's derived data settings.

Chatto.xcworkspace · high confidence

The Chatto framework project has been reorganized with a new folder structure, including dedicated groups for ChatController, Chat Items, Keyboard handling, Utils, and Collaborators. Key components such as BaseChatViewController, ChatMessageCollectionAdapter, and various keyboard tracking utilities are now part of the main framework source. The project also includes test files and configurations for building the Chatto framework.

Chatto/Chatto.xcodeproj · medium confidence

The ChattoAdditions Xcode project has been restructured to improve modularity and build reliability. Resources such as the ChatInputBar.xib, all xcassets, and the new ChattoAdditionsResources bundle are now explicitly managed within a dedicated target, ensuring they are correctly copied and linked. The project also establishes an explicit dependency on the Chatto framework, configures Swift 5 source compatibility, and enables Build Library for Distribution for release builds to support module interoperability.

ChattoAdditions/ChattoAdditions.xcodeproj · high confidence

The ChattoApp demo has been restructured to showcase the framework's updated capabilities. A new message architecture is now available via the shouldUseNewMessageArchitecture flag, introducing compound message support (text, images, emojis) and a new DemoChatMessageFactory. The demo now includes specific example view controllers for testing dynamic content updates, such as swapping message types in-place, reloading entire item sets, and handling asynchronous avatar loading. Additionally, new interactive features are demonstrated, including a swipe-to-reply gesture that triggers an alert, a message selection mode, and a scroll-to-bottom button.

ChattoApp/ChattoApp/Source/Chat View Controllers · high confidence

The project now includes a defined Xcode scheme (ChattoApp.xcscheme) that configures the build, test, launch, profile, analyze, and archive actions. This setup enables code coverage during testing and specifies the primary app and test targets, establishing the baseline development environment for the ChattoApp project.

ChattoApp/ChattoApp.xcodeproj/xcshareddata · high confidence

The keyboard management logic in the chat view has been refactored into distinct, reusable components: \KeyboardTracker\, \KeyboardTrackingView\, and \KeyboardUpdatesHandler\. \KeyboardTracker\ now centralizes observation of system keyboard notifications and exposes a unified \KeyboardState\ enum (showing, shown, hiding, hidden) alongside frame data. \KeyboardTrackingView\ handles layout adjustments based on the observed view's position changes. \KeyboardUpdatesHandler\ coordinates these elements to calculate and expose the necessary bottom margin for input bar positioning via an observable \KeyboardUpdatesInfo\ struct, replacing the previous delegate-based status reporting with a more structured state and info model.

Chatto/sources/Keyboard · high confidence

The chat item handling logic has been restructured to improve modularity and extensibility. A new \BaseChatItemPresenter\ class now serves as the foundation for all cell presenters, managing cell lifecycle events (showing/hiding) and visibility states. Core protocols such as \ChatItemProtocol\, \ChatItemPresenterProtocol\, and \ChatItemPresenterBuilderProtocol\ have been consolidated into \ChatItemProtocolDefinitions.swift\ to standardize how chat items are identified, presented, and built. Additionally, a \DefaultChatItemsDecorator\ and \DecoratedChatItem\ struct have been introduced to handle item decoration attributes, while a \DummyChatItemPresenter\ provides a fallback for unsupported message types, ensuring they render as invisible cells rather than causing errors.

Chatto/sources/Chat Items · high confidence

The chat message display logic has been restructured into a new \ChatMessageCollectionAdapter\ and \ChatMessagesViewController\. The adapter now centrally coordinates updates and collection view data source/delegate responsibilities, while the view controller handles layout, scrolling, and user interaction events. This change decouples the message presentation from the base view controller, introducing a dedicated component for managing chat item updates and collection view positioning.

Chatto/sources/ChatController/ChatMessages · high confidence

The chat interface logic has been restructured to improve modularity and testability. BaseChatViewController now manages the core chat view lifecycle and delegates specific behaviors—such as keyboard updates, collection view scrolling events, and view presentation changes—to injectable handler protocols rather than relying on internal tight coupling. This change introduces new configuration structures like ChatLayoutConfiguration for managing content and scroll indicator insets, and adds utility extensions to UICollectionView for precise scrolling and visibility calculations. For users, this results in a more flexible chat component where input bar positioning, keyboard animations, and scroll behaviors can be customized or replaced via the new handler interfaces.

Chatto/sources/ChatController · high confidence

The chat view controller's internal logic has been reorganized into a set of distinct, protocol-driven collaborator classes to improve testability and customization. Key changes include the introduction of \BaseChatViewControllerView\ to handle input accessory view lifecycle, \CellPanGestureHandler\ and \ChatPanGestureRecogniserHandler\ to manage swipe gestures for revealing timestamps and reply indicators, and \ChatCollectionViewLayout\ to optimize layout calculations. Additionally, \ChatItemPresenterFactory\ is now injectable, allowing developers to provide custom presenter builders, and \UpdateType\ has been converted to a frozen enum to support more specific update notifications like \firstSync\.

Chatto/sources/ChatController/Collaborators · high confidence

The input bar system has been restructured to support customizable animations and more flexible event handling. Two new animation implementations, SpringChatInputBarAnimation and TimingChatInputBarAnimation, are now available via the ChatInputBarAnimationProtocol, allowing the input bar's movement to be driven by spring dynamics or custom timing functions. The presentation logic is now governed by a simplified ChatInputBarPresentingController protocol and a new ChatInputBarPresenterProtocol, which introduces an InputBarMode enum (text or custom) and injectable event handlers for scroll view, collection view, and view lifecycle events. This change decouples the input bar's visual behavior from its container, enabling developers to inject specific animation styles and event handling logic.

Chatto/sources/ChatController/InputBar · high confidence

The chat view's internal architecture for rendering message content has been restructured to support more flexible and explicit layout control. A new \MessageContentFactoryProtocol\ and \AnyMessageContentFactory\ wrapper now standardize how message views, presenters, and layout providers are created. The \DefaultMessageContentPresenter\ has been updated to conform to a new \MessageContentLoadingPresenterProtocol\, enabling explicit tracking of loading states (initial, loading, loaded, cancelled) for cached or remote content. Additionally, the \TextMessageLayoutProvider\ now supports custom \NSParagraphStyle\ configurations and allows passing an original \NSAttributedString\ directly, giving developers finer control over text rendering and layout calculations.

ChattoAdditions/sources/Chat Items/CompoundMessage/Content · high confidence

The ChattoApp module now explicitly specifies Swift 4.0.0 via a new .swift-version file and links to the project's central SwiftLint configuration through a symlink, ensuring consistent language versioning and code style enforcement for this specific app target.

ChattoApp · high confidence

Added test bundle configuration for ChattoAdditions; Added unit tests for BaseMessage presenter and interaction logic; Added unit tests for Chat Input and Photo Input components; Added unit tests for Chatto chat controller components; Added unit tests for Chatto core components; Added unit tests for ChattoAdditions common utilities; Added unit tests for PhotoMessage presenter and builder; Added unit tests for SlidingDataSource; Added unit tests for TextMessagePresenter and its builder.

The Chatto chat framework and its ChattoAdditions UI components have been updated to version 4.1.0. This release raises the minimum iOS deployment target to 11.1 and updates the Swift language version to 5.3. The update includes new or refreshed Podspec files for both libraries, a synchronized Podfile and Podfile.lock for the ChattoApp example project, and an updated Package.swift file to support Swift Package Manager integration.

(dependencies) · high confidence

The CocoaPods target support files for the ChattoApp have been regenerated to reflect the current state of the Chatto and ChattoAdditions dependencies. This update ensures the build system correctly links the Chatto and ChattoAdditions frameworks, embeds their resources, and configures the necessary header and library search paths for both Debug and Release configurations.

ChattoApp/Pods/Target Support Files/Pods-ChattoApp · high confidence

The ChattoApp project's CocoaPods support files for the ChattoAdditions framework have been regenerated and updated. The framework version is now 4.1.0, as reflected in the generated Info.plist and module map files. This update includes new build configuration files (xcconfig) for debug and release modes, a dummy source file for linking, and an umbrella header, ensuring the example app correctly integrates the latest ChattoAdditions version.

ChattoApp/Pods/Target Support Files/Chatto, ChattoApp/Pods/Target Support Files/ChattoAdditions · high confidence

The ChattoApp project's pod dependencies have been updated to synchronize with the latest Chatto library versions. This change ensures the sample application uses the most recent features and fixes from the Chatto framework, including improvements to keyboard handling, input bar customization, and message presentation logic.

ChattoApp/Pods/Pods.xcodeproj · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 64 → 55 (-8.8)
• Rubric changed (rubric-2026.09.11 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 94 → 94 (-0.0)
• Architecture 96 → 91 (-5.3)
• Maturity 49 → 49 (+0.0)
• Readiness 62 → 41 (-21.7)
• Security 84 → 82 (-1.7)

• Ambiguous naming for similar boolean checks. 'shouldShowMenu' and 'canShowMenu' sound semantically identical (both check if a menu is available/allowed). In UIKit, 'shouldShowMenu' is often a delegate method, while 'canPerformAction' is the actual check. Having both suggests a potential logic split (e.g., one for visibility, one for enablement) but the names are not distinct enough to convey this difference.
• Conflicting method names for similar operations. 'configureCell' is overloaded with two very different signatures. One is a simple configuration with optional decoration attributes, the other is a complex configuration with animation and additional closure. This makes the API harder to discover and use correctly.
• Coverage not measured — Swift suite
• Dependency hygiene PARTLY measured — SwiftPM pinning read, dependency currency NOT established
• Documentation: no usage examples (README.md)
• Duplicate intent with different signatures. Same issue as 'cellWillBeShown'. Two methods named 'cellWasHidden' with and without a UICollectionViewCell argument.
• Duplicate intent with different signatures. Two methods named 'cellWillBeShown' exist: one taking a UICollectionViewCell and one taking no arguments. This forces implementers to guess which one to override or call, or suggests that the cell-less version is a default implementation that the cell-taking version calls. This is a common anti-pattern in Swift UI codebases where one is a convenience wrapper for the other.
• Duplicated block (10 lines × 2) (ChattoAdditions/sources/Chat Items/PhotoMessages/PhotoMessagePresenter.swift)
• Medium: security finding (details withheld)
• Projects may be oversized for their cohesion
• Redundant overloads with implicit default behavior. The second method is identical to the first except for an extra boolean parameter 'spotlight'. If 'spotlight' defaults to false, this is acceptable, but if it defaults to true or has complex logic, it creates confusion. More critically, 'ChatMessagesViewController' exposes 'scroll(toItemId: String, position: ScrollPosition, animated: Bool, spotlight: Bool)' as a single method, while 'BaseChatViewController' splits it. This inconsistency in API surface between the base class and the view model layer is confusing.

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

badoo/Chatto was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.