May 2020 Summaries

This tutorial outlines the process of integrating video chat functionality into an iOS application using Dolby.io's Interactivity APIs, previously known as Voxeet. The guide focuses on setting up a 1-on-1 private video chat, utilizing Voxeet's client-side library and a minimal backend setup to manage call notifications and status. Key steps include creating a Dolby account, installing necessary dependencies, configuring the Voxeet UXKit library in the application, and implementing the user interface for initiating and joining calls. The tutorial also covers handling call termination and backend communication to ensure users are informed of active calls. Although the tutorial mentions using the Stream Chat API for a seamless communication experience, it primarily centers on Voxeet's capabilities for managing video calls. The author notes that the content is outdated due to the introduction of Dolby's own Voice & Video Calling API and SwiftUI SDK, which offer enhanced features and support for video chat integration.

Stream Video's newly released Video API allows developers to integrate live video, voice calling, audio rooms, and livestreaming into applications through a single API, complemented by customizable UI Kits for major frontend platforms. The tutorial demonstrates building a live streaming and chat app using Stream Chat and Dolby.io's Client SDK, allowing screen and voice streaming to numerous viewers who can interact via chat. It guides users through setting up an Xcode project, installing dependencies with CocoaPods, configuring Stream Chat and Dolby.io dashboards, and creating a "Join" screen and a "Watch" screen for streaming and chat. The tutorial emphasizes using Stream Chat to enhance in-app messaging and Dolby.io's platform for unified communications, providing a hands-on approach to creating a game live streaming app with system-wide screen sharing capabilities.

This tutorial guides users through building a simple chat application for iOS and macOS using SwiftUI and Stream Chat's Swift SDK. The process involves setting up a SwiftUI project in Xcode, installing the Stream Chat dependency via CocoaPods, and configuring the Stream Chat Dashboard. It details creating a singleton for the chat client, building a login view using SwiftUI to handle user input, and creating a chat view that displays messages in real time. The tutorial also includes steps to improve the user interface, such as creating custom message views similar to iMessage. Although the tutorial uses a basic setup with disabled authentication for simplicity, it emphasizes the need to enable security features in production. The tutorial ends with a functioning chat app foundation, encouraging users to explore Stream Chat's documentation and experiment further, with a promise of a follow-up guide to implement multiple channels.

Live streaming apps, which include major platforms like YouTube, Twitch, and Instagram, are prevalent in app stores, largely due to their interactive Livestream Chat features that enhance user engagement through real-time interaction. The article provides a step-by-step guide to integrating a Livestream Chat feature into an Android app using the Stream SDK, demonstrating how to set up a chat client, create a channel, subscribe to new messages, and send messages. It emphasizes the simplicity of the integration process, highlighting that the sample project requires minimal configuration, yet allows for extensive customization and scalability across various platforms such as Android, iOS, React, and Flutter. Additionally, Stream offers advanced features like roles, message management, reactions, and push notifications, further enhancing the app's capabilities.

Apple's Mac Catalyst enables developers to use a largely shared native codebase for both iOS and macOS apps, streamlining the process of creating desktop versions of iPad apps and enhancing user experience with consistent performance across platforms. This advancement allows existing iPad apps to be efficiently transformed into native Mac apps, reaching an audience of over 100 million active Mac users. Stream Chat's Swift SDK is compatible with Mac Catalyst, allowing chat experiences to translate easily from iOS to macOS, with minor modifications to accommodate platform-specific user experiences. Key features like UI components, context menus, attachment uploads, and push notifications seamlessly transition with minimal additional setup, thanks to the shared codebase. Developers can start building cross-platform chat applications using the Stream Chat iOS/Swift tutorial, ensuring compatibility with Mac Catalyst by simply adjusting deployment settings in Xcode, and addressing specific requirements such as file upload permissions in the .entitlements file.

This tutorial guides users through building an encrypted chat application on iOS using Swift, integrating Stream Chat and Virgil Security to ensure end-to-end encryption, which safeguards messages from being accessed by anyone other than the intended recipient. By embedding Virgil Security's E3Kit with Stream Chat's Swift components, the app encrypts messages on the user's device before transmission, and only the recipient can decrypt them, ensuring that even if the data is intercepted, it remains unreadable. The process involves setting up a backend using Node.js to manage authentication and credentials, and leveraging Stream's UI components to manage the chat interface, while Virgil handles cryptographic operations and key management. The tutorial requires basic knowledge of iOS and Node.js and includes setting up necessary accounts, configuring backend endpoints for authentication tokens, and implementing message encryption and decryption in the app's lifecycle. This results in a chat application that maintains user privacy by ensuring that neither the developers nor any third-party service can access the content of the messages.

Stream Chat has expanded its service offerings by adding two new regions, Singapore and Sydney, to its existing support in US East and EU West. This expansion aims to enhance the availability and reliability of real-time chat infrastructure for users in these regions. Interested parties in these areas are encouraged to reach out for more information on building real-time chat solutions with Stream Chat's infrastructure and support.

In the fourth installment of a tutorial series on building a full-stack application using Flask, React/Redux, and Stream, the article focuses on managing collections of links within a web application, incorporating CRUD operations for creating, editing, and fetching these collections. Users can group links into collections with defined names and descriptions, which can be easily integrated with RSS feeds or adapted for blog content. The tutorial emphasizes the importance of structuring API requests to manage communication between the front and back ends, utilizing constants and reducers to handle state changes within the CollectionEditor component. This involves setting up a reducer to manage collection state, actions to handle form submissions, and components to display and edit collections. Furthermore, it illustrates how to ensure proper routing and user authentication, and how to handle redirection after collection actions. The article also covers converting server-side views to return JSON responses to support a seamless integration between front-end components and the back-end, facilitating the creation, updating, and deletion of collection entries. Lastly, it discusses incorporating collection metadata and actions, ensuring authors can modify their collections while preparing for future enhancements such as integrating chat and implementing infinite scroll for content displays.

In a time when live streaming and video conferencing have surged in popularity due to the need for remote connections, this tutorial provides a comprehensive guide to building a live video streaming app on Android, featuring an integrated chat function using Stream's Chat API. The process begins by cloning a basic project from GitHub, setting up necessary API keys, and configuring the user interface to accommodate video playback and chat messages. The tutorial guides users through implementing a chat feature using Stream's Low-Level Android Client, detailing how to manage user and channel metadata, handle message events, and update the UI with new messages. It emphasizes the utility of Stream's tools for simplifying the integration of chat capabilities without the need to manage complex backend infrastructure, and encourages further exploration of Kotlin Chat Docs and other resources to refine and expand the app's functionality.

Messaging apps provide global communication ease but also pose privacy and security risks, as many popular platforms like Twitter, Instagram, and Facebook Messenger lack end-to-end encryption, leaving conversations vulnerable to third-party access. In contrast, secure messaging apps such as Signal, Wire, and Threema utilize end-to-end encryption to ensure that only the intended recipients can read the messages, offering greater privacy protection. These apps are increasingly sought after in today's connected world and offer features like multi-mode communication, cross-platform synchronization, and open-source protocols, with some even allowing for anonymous use and self-destructing messages. Despite their security benefits, each app varies in additional features, making the choice dependent on individual preferences and requirements for data protection.

A series of tutorials guides users through building a simple social network called The Stream, which enables users to post messages to followers and engage in one-on-one or group chats. The project leverages Stream's Activity Feed API and Chat API along with Swift to streamline the development of complex interactions without the extensive overhead of starting from scratch. The complete source code for the application is available on GitHub, and those eager to see the finished product can refer to Part 3 of the series. Each part of the tutorial, which covers different functionalities like Activity Feeds, Direct Messaging, and Group Channels, is accessible through provided links.

Social logins, such as those provided by Google and Facebook, offer users a convenient alternative to traditional username and password setups by allowing them to sign into applications using existing accounts. Apple introduced its own version, "Sign in with Apple," at their World Wide Developer Conference, enhancing both privacy and usability compared to other platforms. This feature limits data sharing to just the user's email and name, and users can choose to mask their email for added privacy. The integration with iOS ensures seamless access across devices, while Face ID or Touch ID enables fast login. This tutorial guides users through implementing "Sign in with Apple" for a chat application using Stream Chat, covering prerequisites like setting up an Apple Developer Account, configuring Xcode, and building both server and client components. The tutorial emphasizes creating a secure, efficient login process and provides detailed steps for integrating Apple's authentication system into a React Native app, demonstrating its advantages in user verification and app connection.

Part three of the series focuses on integrating group chat functionality into a social application using Stream Chat, building on prior work outlined in parts one and two. The process involves enhancing the iOS application by adding a ChannelsView to the TabView, allowing users to create and join chat channels. The backend already provides the necessary infrastructure to generate frontend tokens for Stream Chat, facilitating direct API communication. Users can navigate through a list of channels, create new channels by providing a name, and interact with the Stream API to broadcast messages to all channel participants. The app utilizes Stream's Swift libraries to handle API communications and UI rendering, including a UIViewController for displaying a list of channels and enabling group chat interaction. Once a channel is selected, Stream's library automatically manages the display and functionality of the group chat interface, resulting in a comprehensive chat feature within the social network application.

The post outlines the process of creating a simple social network application called Stream Flutter using SwiftUI, allowing users to post messages and follow others. The application, functional on both iOS and Android, utilizes Stream's Activity Feed API for complex interactions and provides essential code snippets available on GitHub for further context. The setup involves a backend, using Express with Stream's JavaScript library, and a frontend using Swift with Stream's Swift library. Key functionalities include user registration, posting messages, and forming follower relationships, with the app leveraging Stream's API to manage user feeds and timelines. Users can log in, create status updates, view their posts, and follow other users, with backend code facilitating secure token generation and feed management. The post emphasizes the importance of understanding Node.js, Swift, and SwiftUI, and provides guidance for setting up development environments and troubleshooting issues, encouraging readers to refer to the full source code and documentation for comprehensive understanding.

Building on the first part of the series, the second installment details the integration of direct messaging between users using Stream Chat within a mobile application. The process involves modifying the backend to generate a Stream Chat frontend token, which allows secure client-server communication with Stream's API, bypassing the backend. The implementation leverages Stream's UI components to create an out-of-the-box chat experience, with a focus on ease of setup by utilizing the Stream Chat JavaScript library for the backend and Swift libraries for the mobile app. The app facilitates 1-on-1 chat interactions by allowing users to navigate to a chat channel, query previous messages, and listen for new ones, all handled predominantly by Stream's mobile libraries. Additionally, the article outlines the steps for configuring Stream Chat, including setting up a new client for the Stream Chat API, creating a frontend token during the login process, and integrating navigation features to support seamless transitions between views. The detailed walkthrough includes code snippets for setting up chat functionalities, emphasizing the streamlined integration process enabled by Stream's pre-built components.

The tutorial provides a comprehensive guide on building a realtime messaging application using Django for the backend and Angular for the frontend, leveraging Stream's chat API for enabling messaging capabilities. It begins with setting up a Stream account and initializing a Django project to manage user authentication and API integration, including creating a database model for storing user data. The guide then transitions to setting up the Angular frontend, detailing steps for creating a signup view, handling user state management, and implementing a chat interface that supports sending and receiving messages in real time. Throughout the process, the tutorial emphasizes best practices such as keeping keys secure, enabling Cross-Origin Resource Sharing (CORS) for the Django app, and structuring the application for scalability and maintainability. The tutorial concludes by encouraging developers to explore additional features of the Stream Chat API and to enhance the app's responsiveness and user authentication persistence.

When integrating chat features into a SaaS application, ensuring that users' private messages remain secure and isolated is crucial, particularly when clients may be competitors, like Nike and Adidas. Stream Chat offers a solution by allowing applications to be configured in multi-tenant mode, where users are organized into distinct teams that cannot interact with each other. This setup prevents potential breaches of privacy by ensuring that users can only access channels and search for other users within their own teams. Stream Chat manages this division of users and channels, mitigating the risk of data-sharing errors and offering a reliable way to maintain privacy and security in a shared messaging platform.

The tutorial provides a comprehensive guide to integrating the "Sign in with Apple" feature into an iOS app, specifically using a clone of Apple's iMessage as an example. It highlights the necessary prerequisites, including iOS 13+, Xcode 11+, Node.js 10+, a Stream account, and enrollment in the Apple Developer Program. The process begins by configuring the client project, adding the sign-in button with the AuthenticationServices framework, and setting up the backend using Node.js and Express to handle authentication requests. The tutorial explains how to authenticate users through Apple ID, using ASAuthorizationAppleIDProvider to create a request and handling the response to authenticate users and configure the Stream client. It offers troubleshooting tips and access to a GitHub repository for reference, ensuring a smooth implementation of this secure sign-in method, which includes two-factor authentication and does not track user activity. The tutorial concludes by emphasizing the importance of adhering to Apple's guidelines and suggests exploring Stream's documentation for additional app features.