InRhythm

Your partners in accelerated digital transformation

Android

Propelling Ahead Of The Android AR Core Curve: A Guide To Implementation And Future Trends

Overview

Augmented Reality (AR) is revolutionizing the way we interact with digital content and information. With the advent of Android AR Core, Google’s AR platform, developers have unprecedented tools at their disposal to create immersive and interactive AR experiences for Android devices. 

In this article, we will dive into the world of Android AR Core, exploring its core concepts, implementation strategies, and what the future holds for AR development:

  • Overview
  • Understanding Android AR Core
  • Getting Started With Android AR Core
  • Emerging Best Practices
  • The Future Of Android AR Development 
  • Closing Thoughts

Understanding Android AR Core

Android AR Core is a software development kit (SDK) that allows developers to build AR applications for Android devices. It leverages a device’s camera and sensors to recognize and interact with the real world. AR Core enables the placement of virtual objects in the physical environment, creating a seamless blend between the digital and physical worlds.

Getting Started With Android AR Core

Implementing AR Core into your Android application may seem complex, but Google has provided a wealth of resources and documentation to guide developers through the process. 

Here are the fundamental steps to get started:

  • Set Up Your Development Environment 

Ensure you have Android Studio and the AR Core SDK installed.

  • Create A Project

Start a new Android project in Android Studio or integrate AR Core into an existing one.

  • Understand Motion Tracking

AR Core uses motion tracking to understand the device’s position and orientation in the physical world. Learn how to enable and work with motion tracking.

  • Environmental Understanding

AR Core recognizes flat surfaces and feature points in the environment, allowing you to place objects accurately. Dive into environmental understanding to make your AR experiences more engaging.

  • Hit Testing

Learn how to detect when a virtual object intersects with a real-world object, enabling interactions.

  • Lighting And Reflection

AR Core considers the lighting conditions in the environment, ensuring that virtual objects appear natural and realistic.

Emerging Best Practices

As AR Core continues to evolve, certain best practices are emerging for developers:

  • Prioritize Performance

AR experiences demand real-time rendering and tracking. Optimize your application for performance to ensure a smooth user experience.

  • User-Centered Design

Create AR experiences that enhance user interactions with the physical world rather than overshadowing them.

  • Multi-Platform Compatibility

As AR Core expands to support more Android devices, aim for compatibility across various screen sizes and resolutions.

  • Experiment With Interaction

Explore novel ways for users to interact with AR content, such as gestures and voice commands.

The Future Of Android AR Development

The future of Android AR Core development is brimming with possibilities. As AR technology matures, we can expect:

  • Wider Adoption

With more Android devices supporting AR Core, AR applications will reach a broader audience.

  • Improved Realism

Advances in computer vision and machine learning will lead to more realistic AR experiences.

  • Cross-Platform Integration

Expect greater integration between Android AR Core and other AR platforms, enabling cross-platform AR applications.

Closing Thoughts

Android AR Core opens up a world of exciting opportunities for Android developers. By understanding its fundamentals, best practices, and future trends, you can position yourself at the forefront of this transformative technology. As AR becomes an integral part of our daily lives, your expertise in Android AR Core development will be more valuable than ever. 

Get ready to build the next generation of immersive, interactive, and visually stunning AR experiences on Android devices!

Unleashing The Power Of Jetpack Compose Tooling: A Comprehensive Guide

Based on a Lightning Talk by: Minhazur Rahman, Senior Android Developer @ InRhythm on October 19th, 2023

Overview

In the ever-evolving realm of Android app development, creating efficient, aesthetically pleasing, and user-friendly applications is paramount. With the advent of Jetpack Compose, Google’s modern Android UI toolkit, the Android developer’s toolkit has been enhanced significantly. While Compose’s declarative approach has revolutionized how user interfaces are built, the toolkit’s tooling support further boosts development efficiency and quality.

In Minhazur Rahman’s Lightning Talk, we explored Jetpack Compose Tooling for Android development, delved  into its significance and how it could streamline the app-building process. We’ll uncover how Jetpack Compose Tooling simplifies tasks like UI design, navigation, debugging, and more, with real-world examples.

  • Overview
  • The Significance Of Jetpack Compose Tooling
  • The Necessity Of Jetpack Compose Tooling
  • A Hands-On Look At Jetpack Compose Tooling
  • Closing Thoughts

The Significance Of Jetpack Compose Tooling

The Android ecosystem has evolved significantly over the years. As a result, the Android developer community faced the need for a more modern, flexible, and efficient toolkit for building user interfaces. Jetpack Compose emerged as a solution, offering a declarative way to create UI components. But the toolkit’s power is not confined to just UI building. It extends to tooling, which plays a crucial role in Android development. Tooling refers to the software and utilities that support the development process, including design, coding, testing, and debugging.

The Necessity Of Jetpack Compose Tooling

  • Simplifying UI Design

With Jetpack Compose Tooling, creating a visually appealing user interface is more straightforward than ever. The Layout Inspector enables developers to inspect the UI’s structure, helping identify any layout issues and allowing for quick fixes. This is particularly beneficial when designing complex UIs with multiple components.

Imagine you’re developing a music streaming app with an intricate music player UI. Jetpack Compose Tooling’s Layout Inspector can help you visualize the hierarchy of composables that make up the player screen, ensuring that all elements are correctly placed and aligned.

  • Efficient Debugging

Debugging is an integral part of software development. Jetpack Compose Tooling comes with advanced debugging capabilities, including live updates. Developers can inspect the state of the UI and, in real-time, see how the interface responds to code changes. This feature enhances the debugging process significantly.

Let’s say you’re building a finance app with various charts and graphs. Using the real-time debugging feature of Jetpack Compose Tooling, you can modify the code for rendering financial data graphs and instantly see how the changes affect the visual representation of data.

  • Composable Navigation

Creating smooth and intuitive navigation between different screens in an Android app is crucial. Jetpack Compose Navigation simplifies this process by providing a type-safe API for navigation within a Composable-based app.

In a news app, Jetpack Compose Tooling can be used for easy and reliable navigation between the homepage, article details, and search results screens. This ensures a seamless user experience when transitioning between different sections of the app.

  • Performance Optimization

Compose Tooling includes tools for performance optimization. The Layout Validation tool helps ensure your UI runs efficiently. By identifying performance bottlenecks, you can optimize your app for smoother user interactions.

Consider a video streaming app. With Jetpack Compose Tooling, you can identify any UI rendering issues that may affect video playback performance and quickly address them.

A Hands-On Look At Jetpack Compose Tooling

Let’s take a hands-on approach to understand how Jetpack Compose Tooling is employed in the development process. We’ll use a simple example of a to-do list app to demonstrate its key features:

  • Composable Layout Inspector

The Layout Inspector, an essential tool in Jetpack Compose Tooling, enables you to visualize the hierarchy of composables and identify any issues in the layout. For instance, in our to-do list app, you can use the Layout Inspector to ensure that the task list, checkboxes, and buttons are correctly placed and aligned.

  • Real-Time Debugging

Real-time debugging is invaluable during app development. As we code the task list UI, Jetpack Compose Tooling allows us to instantly see how changes to the UI components affect the app’s appearance.

  • Composable Navigation

In the to-do list app, we implement a Composable-based navigation system. Jetpack Compose Navigation simplifies screen-to-screen navigation, ensuring users can add and view tasks seamlessly.

  • Performance Optimization

The to-do list app’s UI rendering performance is essential for a responsive user experience. Jetpack Compose Tooling’s Layout Validation tool helps identify and address performance bottlenecks in real time.

Closing Thoughts

Jetpack Compose Tooling is more than just a set of utilities. It’s a gateway to unleashing the full potential of Jetpack Compose for Android app development. With its features for UI design, efficient debugging, composable navigation, and performance optimization, Jetpack Compose Tooling simplifies the development process and helps developers create high-quality, efficient, and visually appealing Android applications.

Unleashing The Power Of Foldable Devices: Exploring Android Foldable APIs

Based on a Lightning Talk by: Bryan Jiang, Senior Android Engineer @ InRhythm on July 13th, 2023

Overview

Foldable devices have introduced a new era of innovation and user experience in the Android ecosystem. These devices offer unique form factors with flexible displays that can adapt to various usage scenarios. To fully leverage the potential of foldable devices, Google has introduced Foldable APIs, a set of powerful tools and features that enable developers to create engaging and seamless experiences for users.

In Bryan Jiang’s Lightning Talk session, we will delve into the world of Android Foldable APIs, exploring their capabilities, implementation techniques, and the latest advancements:

  • Overview
  • Understanding Android Foldable APIs
  • Key Features And Capabilities Of Android Foldable APIs
  • Implementation Techniques And Best Practices
  • Latest Advancements And Resources
  • Closing Thoughts

Understanding Android Foldable APIs

Android Foldable APIs provide developers with a comprehensive set of tools to adapt their apps to foldable devices. These APIs enable developers to detect and respond to changes in device configuration, such as folding, unfolding, or transitioning between different modes (ie. single-screen, dual-screen). By utilizing Foldable APIs, developers can optimize their apps for multi-window workflows, resizable layouts, and enhanced user interactions on foldable devices.

Key Features And Capabilities Of Android Foldable APIs

  1. Screen Continuity
  • Foldable APIs allow developers to seamlessly transition between different screen configurations and adapt the app’s layout and content accordingly
  • Developers can handle events like folding and unfolding, preserving app state and providing a consistent user experience
  1. Multi-Window Support
  • Foldable APIs enable developers to design apps that can span across multiple screens, taking full advantage of the larger display real estate on foldable devices
  • Developers can create multi-window experiences, allowing users to interact with multiple app components simultaneously
  1. Hinge And Display Metrics
  • Foldable APIs provide access to hinge angle and display metrics, enabling developers to dynamically adjust the app’s layout and behavior based on the device’s physical characteristics
  • Developers can optimize their apps to utilize the full potential of foldable devices and provide a seamless experience regardless of the device’s posture

Implementation Techniques And Best Practices

  1. Configuring The Manifest
  • Update the manifest file to declare support for foldable devices and specify the app’s behavior for different screen configurations
  • Use the <supports-screens> and <compatible-screens> elements to ensure compatibility across various foldable device models
  1. Handling Configuration Changes
  • Implement appropriate lifecycle callbacks and listeners to detect and respond to changes in device configuration, such as folding and unfolding events
  • Dynamically update the app’s layout, resources, and user interface to adapt to different screen modes
  1. Multi-Window Layouts
  • Design responsive layouts that can adapt to multiple windows, taking advantage of the expanded screen real estate
  • Utilize ConstraintLayout or other adaptive layout techniques to ensure proper rendering and usability in multi-window scenarios

Latest Advancements And Resources

  1. Jetpack WindowManager
  1. Google Developer Documentation
  1. Foldable Device Emulators And Hardware

Closing Thoughts

Android Foldable APIs empower developers to create immersive and adaptable experiences for foldable devices. By leveraging the capabilities of Foldable APIs, developers can optimize their apps for multi-window workflows, responsive layouts, and seamless transitions on foldable devices. Stay up to date with the latest advancements, documentation, and community resources to unlock the full potential of Android Foldable APIs and provide exceptional user experiences on these innovative devices.

Building Compose-Driven Architecture On Android With Circuit

Based on a Lightning Talk by: Trevor Crawford, Senior Android Engineer @ InRhythm on June 8th, 2023

Overview

As the Android ecosystem evolves, developers are continuously seeking efficient ways to build and architect modern, scalable, and maintainable applications. One approach gaining traction is the adoption of a Compose-driven architecture, which leverages Jetpack Compose, the declarative UI toolkit introduced by Google. 

In Trevor Crawford’s Lightning Talk session, we will explore how developers can harness the power of Circuit to build a Compose-driven application architecture on Android. We will delve into the benefits, principles, and implementation techniques of this approach:

  • Overview
  • Understanding Compose-Driven Architecture
  • The Role Of Circuit
  • Benefits Of Compose-Driven Architecture With Circuit
  • Implementation Techniques
  • Closing Thoughts 

Understanding Compose-Driven Architecture

Compose-driven architecture is centered around Jetpack Compose, a powerful UI toolkit that enables developers to build responsive and flexible user interfaces. It emphasizes the use of declarative programming, allowing developers to describe the UI state and behavior using a concise and intuitive syntax. Compose-driven architecture promotes modularity, reusability, and testability by breaking down the UI into smaller, composable components. These components can be combined and composed to build complex UI screens, providing a more efficient and maintainable development experience.

The Role Of Circuit

Circuit is an open-source library  and framework that complements Compose-driven architecture by providing additional tools and patterns. These circuits offer ready-to-use solutions for common challenges in building Android applications, such as state management, navigation, dependency injection, and data fetching. Circuit enables developers to follow best practices and leverage pre-built components, saving time and effort in developing the core infrastructure of the application. Additionally, they foster a collaborative and supportive community, enabling developers to learn from and contribute to shared knowledge.

Benefits Of Compose-Driven Architecture With Circuit

  • Increased Productivity And Development Efficiency 

Compose-driven architecture, coupled with open-source circuits, boosts developer productivity by providing a modular and reusable approach. Composable UI components and pre-built circuit libraries enable faster development and reduce boilerplate code. The declarative nature of Compose simplifies UI updates, while open-source circuits handle complex tasks, freeing up developers to focus on business logic and unique features.

  • Improved Testability And Maintainability

Compose-driven architecture promotes testability by separating UI logic from business logic. With smaller and composable components, unit testing becomes more straightforward. Open-source circuits often provide testing utilities and patterns, enabling developers to write comprehensive tests for UI components and application logic. This approach results in more stable, maintainable, and bug-resistant codebases.

Implementation Techniques

  • Modularization And Separation Of Concerns

Compose-driven architecture encourages modularization and separation of concerns. Divide the application into modules based on features or layers, such as presentation, domain, and data. Each module can encapsulate its UI components, business logic, and data management, ensuring a clear separation of responsibilities and promoting code organization.

  • Leveraging Open-Source Circuits

Identify the key architectural concerns in your application and explore relevant open-source circuits. Integrate these circuits into your project using dependency management tools like Gradle. Follow the provided documentation and examples to adopt the circuit’s patterns and utilities within your Compose-driven architecture.

  • Composable UI Components

Break down your UI into small, reusable, and self-contained composable components. Circuit’s UI and State concepts make it simple to define, test and preview your UI’s composable functions. Your UI will send CircuitEvents back to the Presenter, which then updates the CircuitState. This circular loop completes the “Circuit” and makes for an easy to follow and intuitive architecture.

Closing Thoughts

By utilizing the power of Compose-driven architecture with Circuit, developers can build scalable, maintainable, and efficient Android applications. This approach offers benefits like increased productivity, improved testability, and flexibility. Leveraging modularization, separation of concerns, and pre-built Circuit libraries, developers can focus on delivering high-quality features while adhering to best practices. Embrace Compose-driven architecture with open-source circuits to elevate your Android development experience and create exceptional applications.

InRhythm Presents The Propel Spring Quarterly Summit

Design Credit: Joel Colletti, Lead UI/UX Designer @ InRhythm

New York, NY – InRhythm recently concluded its very first Propel Spring Quarterly Summit; a premiere event consisting of six individual coding workshops aimed to support the learning and growth of engineering teams around the world. 

Over the last three weeks, our consulting practices have led a series of interactive experiences that delved into the latest technology trends and tools, designed to propel professionals forward into their careers. 

The workshops are free to access as a unique part of InRhythm’s mission to build a forward-thinking thought leadership annex:

Design Credit: Joel Colletti, Lead UI/UX Designer @ InRhythm

SDET Workshop (03/17/23)

Design Credit: Joel Colletti, Lead UI/UX Designer @ InRhythm

This workshop worked as an introduction to writing and running tests using Microsoft Playwright. Our SDET Practice went over Playwright’s extensive feature set before diving more in-depth with its API.  

For the workshop, the team went over setup and installation of the tool, as well as wrote a series of comprehensive tests against a test application. Once tests were run, the team afforded participants the opportunity to go over some of Playwright’s advanced features, such as its powerful debugger and enhanced reporting. 

To close out the workshop, SDET Practice Leadership compared Playwright’s features to some of its competitors, went over its pros and cons, and discussed why they believed it to be a paramount tool to consider for automated testing solutions.

Web Workshop (03/24/23)

Design Credit: Joel Colletti, Lead UI/UX Designer @ InRhythm

Our Web Practice focused their workshop on their top three, intertwining technologies for development cycles. 

With many modern web applications sharing many of the responsibilities that a middle layer/presentation and service layer/backend provide to the frontend layer, the project was kicked off by organizing the elements with a mono-repository.  

Once the application moved into its build phase, it was time to accelerate the architecture to the next level using NextJS. 

Web Practice Leadership wrapped their project, with an intuitive overview of web bundling and the variety of methods utilized – in order to best adapt to each individual build.

DevOps Workshop (03/29/23)

Design Credit: Joel Colletti, Lead UI/UX Designer @ InRhythm

In this workshop, the DevOps Practice demonstrated tools for provisioning infrastructure as well as how to construct a self-servicing platform for provisioning resources. With these new developments in the industry, bridging the gaps between development and ops by allowing developers to self-manage cloud infrastructure to satisfy their needs will be a paramount skill to adopt. Our DevOps practitioners discussed the pros and cons of a number of tools for provisioning infrastructure and identified which tools can best fit a business’ needs.

For the hands-on interactive session, the team ran through the necessary steps to get started with Pulumi and provision a resource onto AWS, along with demonstrating Terraform in order to get a feel for the difference between the two popular infrastructure-as-code tools. After that, we set up some plugins to enhance the development experience with IaC.  

Self-servicing platforms are the best way to allow for engineers to provision resources and infrastructure for their needs en-masse. With Backstage, the team was able to demonstrate a platform for engineers to come to and fulfill their needs whether it be creating a new microservice, a new repository, or even provisioning a new k8s cluster. Furthermore, the provisioning of these resources were proven to standardize and bring uniformity to ensure that best practices are enforced. Long gone are the days of submitting a ticket to create a new instance to deploy an application, with a wait time of a few hours or even a few days.  Self-servicing tools are the future of bringing operations into the hands of developers and bridging the gap between development and operations.

Finally, DevOps Practice Leadership set up a self-servicing platform and hooked it into the aforementioned IaC repository to allow for the provisioning of resources from a GUI. 

Managing infrastructure can quickly become tedious as the number of resources being used on a cloud provider continue to grow.  With infrastructure-as-code, not only DevOps engineers, but developers can now lay out infrastructure using code. Since it’s managed via code, version-controlling/source-code management tools are also available, making management of infrastructure significantly easier.

iOS Workshop (03/28/23)

Design Credit: Joel Colletti, Lead UI/UX Designer @ InRhythm

Our iOS Practice did a full overview of Swift Async/Await for iOS application development

Async/Await is a programming feature that simplifies asynchronous operations by allowing software engineers to write asynchronous code in a synchronous manner. It also makes code easy to read/write, improves performance/responsiveness, and reduces the likelihood of errors.

In short, Async/Await is a powerful modern feature in every avenue from development speed and simplified code to and application performance.

Android Workshop (04/11/23)

Design Credit: Joel Colletti, Lead UI/UX Designer @ InRhythm

Our Android Practice performed a comprehensive demonstration of the practical integration of Kotlin Multi-Platform Mobile (KMM) for cross-platform development. 

Kotlin Multi-Platform Mobile is an exciting, growing new technology that allows sharing core code between Android, iOS, and Web.  

In this workshop, Android Practice Leadership explored what KMM was, how to setup a project for KMM, a walkthrough implementing a core module to a few APIs (network layer, data models, parsers, and business logic), and then consumed this core library in an Android (Jetpack Compose) and iOS (SwiftUI) application.

Cloud Native Application Development Workshop (04/21/23)

Design Credit: Joel Colletti, Lead UI/UX Designer @ InRhythm

In this workshop our Cloud Native Application Development Practice introduced the participants to gRPC, which is Google’s take on Remote Procedural Calls. Our Practice Leadership presented a brief history of gRPC and Protocol Buffers. Google and other companies use gRPC to serialize data to binary which results in smaller data packets. Throughout the presentation our team went over some of the pros and cons of using gRPC for individual API calls.

In our hands-on workshop portion participants created a simple application to manage users and notes powered by Java, gRPC, and Postgres. The grand finale featured a full-circle moment as we worked together to create a series of CRUD APIs in Java using gRPC to send/receive data packets, translate those into objects, and store them in a database.

About InRhythm

InRhythm is a leading modern product consultancy and digital innovation firm with a mission to make a dent in the digital economy. Founded in 2002, InRhythm is currently engaged by Fortune 50 enterprises and scale-ups to bring their next generation of modern digital products and platforms to market. InRhythm has helped hundreds of teams launch mission-critical products that have created a positive impact worth billions of dollars. The projects we work on literally change the world.

InRhythm’s unique capabilities of Product Innovation and Platform Modernization services are the most sought-after. The InRhythm team of A+ thought leaders don’t just “get a job,” they join the company to do what they love. InRhythm has a “who’s who” clients list and has barely scratched the surface in terms of providing those clients the digital solutions they need to compete. From greenfield to tier-one builds, our clients look to us to deliver their mission-critical projects in the fields of product strategy, design, cloud native applications, as well as mobile and web development.