If the answer is no, don’t worry I’m here to take you through the Modern Android Development (MAD) journey.

Are you ready to travel around the modern android world? Less go!!!

According to Google’s official document –

MAD comprises development tools, APIs, language, and distribution technologies recommended by the Android team to help developers be productive and create better apps that run across billions of devices.

Features of Modern Android Development

• Created by Experts — Brings together learnings from a decade of leading-edge Android app development.
• Squash fragmentation and get to the fun fast — Reduce complexity with libraries that work consistently across more devices, while breezing through app basics with tools and libraries that reduce boilerplate.
• For all levels and speeds — Engineered to work for every developer and team, no matter how big or small, built to work together, while letting you use what you need when you need it.

Development Essentials for MAD

An expanding collection of modern technologies that can take you from coding to distribution. 

• 
  

  Kotlin

  
  

Kotlin is a modern, trending programming language that was released in 2016 by JetBrains. 

Kotlin is used for mobile applications (especially Android apps), Web development, Server side applications, Data Science, and much, much more!

Kotlin is an expressive and concise programming language that reduces common code errors and easily integrates into existing apps. Many developers already enjoy using Kotlin, and the request for more Kotlin support is clear. 

1. Expressive and concise: You can do more with less. Express your ideas and reduce the amount of boilerplate code. 67% of professional developers who use Kotlin say Kotlin has increased their productivity.
2. Safer code: Kotlin has many language features to help you avoid common programming mistakes such as null pointer exceptions. Android apps that contain Kotlin code are 20% less likely to crash.
3. Interoperable: Write Java-based code in Kotlin, or write Kotlin in Java-based code. Kotlin is 100% interoperable with the Java programming language.
4. Structured Concurrency: Kotlin coroutines make asynchronous code as easy to work with as blocking code. Coroutines dramatically simplify background task management for everything from network calls to accessing local data.

Today over 70 of Google’s apps are built using Kotlin. This includes apps like Maps, Home, Play, Drive, and Messages. One example of success comes from the Google Home team, where migrating new feature development to Kotlin resulted in a 33% reduction in codebase size and a 30% reduction in the number of NPE crashes.

• 
  

  Android Studio

  
  

Android Studio is the official integrated development environment for Google’s Android operating system, built on JetBrains’ IntelliJ IDEA software and designed specifically for Android development. 

It is available for download on Windows, macOS, and Linux-based operating systems.

• 
  

  Android App Bundle

  
  

An Android App Bundle is a publishing format that includes all your app’s compiled code and resources, and defers APK generation and signing to Google Play. 

Read more here.

• 
  

  JetPack Compose

  
  

JetPack Compose is now a part of Modern Android Development. JetPack Compose is Android’s modern toolkit from Google to build native UI.

Many Kotlin Android developers are in love with this new way of designing UI. JetPack Compose made dealing with recycler views, navigation, and animations so easy and straightforward.

We will discuss JetPack Compose in detail later in this article.

Things you must know about Modern Android Development

Lifecycle: 

Lifecycle-aware components perform actions in response to a change in the lifecycle status of another component, such as activities and fragments.

The androidx.lifecycle package provides classes and interfaces that let you build lifecycle-aware components—which are components that can automatically adjust their behavior based on the current lifecycle state of an activity or fragment.

Most of the app components that are defined in the Android Framework have lifecycles attached to them. They are core to how Android works and your application must respect them. Not doing so may trigger memory leaks or even application crashes.

To learn more about handling lifecycles with lifecycle-aware components, here are the additional resources — 

Sunflower is a demo app demonstrating best practices with Architecture Components.

ViewModel:

The alternative to a ViewModel is a plain class that holds the data you display in your UI. This can become a problem when navigating between activities or Navigation destinations. 

Doing so destroys that data if you don’t store it using the saving instance state mechanism. ViewModel provides a convenient API for data persistence that resolves this issue.

The key benefits of the ViewModel class are:

• It allows you to persist UI state.
• It provides access to business logic.

Explore Jetchat for further information about the ViewModel class.

Work Manager:

WorkManager provides a set of APIs that makes it easy to schedule asynchronous tasks for immediate or deferred execution. 

The WorkManager API is the recommended replacement for all previous Android background scheduling APIs, including FirebaseJobDispatcher, GcmNetworkManager, and Job Scheduler.

Check out the Getting started guide to start using WorkManager in your app.

Room:

Room is an SQLite object mapping library. You can use it to avoid boilerplate code and easily convert SQLite table data to Objects.

Here are blog posts to help you get started with Room:

• 7 Pro-tips for Room
• Incrementally migrate from SQLite to Room

Paging:

The Paging Library helps you load and display small chunks of data at a time. Loading partial data on demand reduces the usage of network bandwidth and system resources. 

To view complete examples of how this library functions, try out the codelab and samples provided by Google.

Codelab — Android Paging Basics codelab

Sample — Android Architecture Components Paging sample

JetPack Compose:

JetPack Compose is a modern toolkit to quickly bring your app to life with less code, powerful tools, and intuitive Kotlin APIs.

What’s next in JetPack Compose

• Performance Improvements
• Material 3 Support
• Tooling
• Platform Support

Explore this GitHub repository of compose sample apps all in one place — https://github.com/android/compose-samples

Navigation:

Android Jetpack’s Navigation component helps you implement navigation, from simple button clicks to more complex patterns, such as app bars and the navigation drawer.

For more documentation and resources related to the Navigation component, visit Get started with the Navigation component

Material Design:

Material is an adaptable system of guidelines, components, and tools that support the best practices of user interface design. 

It is backed by open-source code, Material streamlines collaboration between designers and developers and helps teams quickly build beautiful products.

CameraX:

CameraX is a Jetpack library, built to help make camera app development easier. For new apps, Google recommends starting with CameraX. 

It provides a consistent, easy-to-use API that works across the vast majority of Android devices, with backward compatibility to Android 5.0 (API level 21).

To learn more about CameraX, consult the following additional resources.

Codelab — Getting Started with CameraX

Code sample — CameraX sample apps

ConstraintMotionLayout:

ConstraintLayout allows you to create large and complex layouts with a flat view hierarchy (no nested view groups). 

It’s similar to RelativeLayout in that, all views are laid out according to relationships between sibling views and the parent layout, but it’s more flexible than RelativeLayout and easier to use with Android Studio’s Layout Editor.

Sunflower, an android sample repository also uses ConstraintLayout.

That’s a wrap! So here is the guideline for you to get started with Modern Android Development.

The post Things to know about Modern Android Development (MAD) appeared first on Talent500 blog.

What’s Hybrid App Framework?

Hybrid app framework that allows developers to create multi-platform apps using a single code base. It uses technologies like HTML, CSS, JavaScript, and native APIs provided by mobile operating systems to create applications that can run on multiple platforms.

Advantage Of Hybrid framework

Development Cost:

Hybrid app development can be more cost-effective than building separate native apps, as a single codebase can be used for multiple platforms, reducing the need for multiple development teams.

Easy access to native device features:

Hybrid apps can access native device features, such as the camera, GPS, or accelerometer, using a bridge provided by the hybrid framework. This allows developers to create apps with native-like functionality without having to write platform-specific code.

Easier maintenance:

Rather than updating a separate code base for each platform developers only need to maintain and update only one set of the code base.

Faster time-to-market:

Hybrid app frameworks offer a faster development process compared to building native apps. It may cut down development time and efforts by 60 to 70%. As developers only need to write code once, rather than building separate codebases for each platform.

Wider audience reach:

Hybrid apps can be deployed across multiple platforms, allowing businesses to reach a wider audience and maximize their app’s potential user base.

Disadvantage Of Hybrid framework

Complexity:

Hybrid app development can be complex and require specialized skills and tools, especially when it comes to integrating with native features and optimizing performance.

Performance Issue:

Hybrid apps may not perform well as compared to native apps.

Limited access to native APIs:

While hybrid apps can access some native APIs, they may not have access to all the features that are available in native apps, which can limit functionality.

Limited user experience:

Hybrid apps may not offer the same level of user experience as native apps, especially for apps that require advanced graphics, animations, or multimedia.

Dependence on third-party frameworks:

Businesses may be dependent on third-party hybrid app frameworks, which can limit their control over the development process and make them vulnerable to security and reliability issues.

Here are the top 4 hybrid frameworks that dominate the cross mobile app development market.

1. Flutter
2. React Native
3. KMM (Kotlin Multiplatform Mobile)
4. .NET MAUI (Multi-platform App UI)

1. Flutter

Flutter is a hybrid app development framework built by Google. It’s open source and gained popularity in recent years as a powerful hybrid framework for building high-performance, beautiful, and native-like mobile applications for both Android and iOS platforms.

Flutter allows developers to build apps for multiple platforms with a single codebase, using Google’s Dart programming language. It was first introduced in 2017 and has since gained popularity due to its high performance, rich set of widgets, and fast development cycle.

Here are some features of Flutter.

Customizable Widgets
Flutter has a wide range of customizable widgets that can be used to build unique and beautiful user interfaces for mobile apps.

Fuchsia OS Support:
Developers can also build applications for the Fuchsia platform.

Hot Reload:
Flutter allows developers to make changes to the code and see the results instantly using its hot reload feature. This can save time and speed up the development process.

Built-in Testing and Debugging:
Flutter provides built-in testing and debugging tools, which can help developers catch and fix bugs quickly and easily.

Multiplatform Support:
Flutter is not only limited to mobile apps you can also make desktop and web-based applications. 

2. React Native

React Native is an open-source framework developed by Facebook and is used to build mobile apps for both iOS and Android platforms.

It allows developers to build apps for both iOS and Android platforms with a single codebase. The framework uses the same design principles as React, a popular JavaScript library used for building web applications. React Native offers a set of pre-built components that can be used to build mobile apps for both iOS and Android platforms.

Here are some features of React Native. 

Pre-built Components:
React Native offers a set of pre-built components that can be used to build mobile apps. This can help developers to build apps quickly and efficiently.

JSX Syntax:
React Native uses a syntax called JSX, which allows developers to write code that looks similar to HTML. This can make it easier for web developers to get started with mobile app development.

Third-Party Libraries:
React Native supports a wide range of third-party libraries, which can be used to add additional features and functionality to mobile apps.

Large Community:
React Native has a large and active community of developers. This means that developers have access to a wide range of resources, tutorials, and plugins to help them build better apps.

3.KMM (Kotlin Multiplatform Mobile)

Kotlin Multiplatform Mobile is an SDK for iOS and Android app development. It offers all the combined benefits of creating cross-platform and native apps.

It is an open-source framework developed by JetBrains, the company behind the Kotlin programming language. KMM allows developers to share common code across both Android and iOS platforms. The framework provides access to a set of platform-specific libraries, which allows developers to use the native features of each platform. KMM uses a common programming language, Kotlin, for both Android and iOS development. This means that developers can use the same language, IDE, and build systems for both platforms.

Here are some features of KMM. 

Code Sharing:
KMM allows developers to use a single codebase to build mobile apps for both Android and iOS platforms. This can save development time and reduce costs for businesses.

Native Performance:
KMM allows developers to use native components of each platform, which means that apps built with KMM have native-like performance.

Common Language:
KMM uses Kotlin, a modern and powerful programming language that is easy to learn and use. This can make it easier for developers to write code for both Android and iOS platforms.

Access to Platform-Specific Libraries:
KMM provides access to a set of platform-specific libraries, which allows developers to use the native features of each platform.

IDE Support:
KMM is fully supported in Android Studio, the official IDE for Android development. This means that developers can use the same IDE for both Android and iOS development.

Reduced Development Time:
KMM can help businesses save money as it requires less development time and can be used to build apps for multiple platforms with a single codebase.

4. .NET MAUI (Multi-platform App UI)

.NET Multi-platform App UI (.NET MAUI) is a cross-platform framework for creating native mobile and desktop apps with C# and XAML.

It is the evolution of Xamarin Forms, a previous hybrid app development framework also developed by Microsoft. It is an open-source framework that allows developers to create mobile apps for multiple platforms using a single codebase. It uses the .NET runtime and C# programming language, which are both widely used by developers for building high-performance, scalable applications. 

.NET MAUI provides a set of common UI elements that work across all platforms, as well as platform-specific APIs and libraries that allow developers to access native functionality on each platform. 

Here are some features of .NET MAUI. 

Visual Studio Support:
.NET MAUI is fully supported in Visual Studio, the official IDE for .NET development. This means that developers can use the same IDE for multiple platform development.

Native Performance:
.NET MAUI allows developers to use native components of each platform, which means that apps built with .NET MAUI have native-like performance.

Access to Platform-Specific Libraries:
.NET MAUI provides access to a set of platform-specific libraries, which allows developers to use native features of each platform.

Common Language:
.NET MAUI uses C#, a modern and powerful programming language that is easy to learn and use. This can make it easier for developers to write code for multiple platforms.

Conclusion

Flutter is a great choice for developers who want to build visually appealing, high-performance mobile apps with a fast development cycle.

React Native is an excellent choice for developers who want to create cross-platform mobile apps with a focus on performance and native-like user experiences. 

Kotlin Multiplatform Mobile (KMM) is a good choice for developers who want to write apps for both Android and iOS platforms using a single codebase. It uses Kotlin as its programming language, which is becoming increasingly popular among developers and provides native performance for both platforms. 

.NET MAUI is a powerful hybrid mobile app development framework that offers a range of benefits for developers and businesses, including code sharing, native performance, and access to platform-specific libraries. Its use of the C# programming language and Visual Studio support make it a great choice for developers familiar with the .NET ecosystem. 

Choosing a framework depends on several factors including development time, cost, performance, and user experience. Each framework has its own strengths and weaknesses, and the best choice will depend on the specific needs and goals of your project.

The post Hybrid App Framework Trend In 2023 appeared first on Talent500 blog.

In this blog, we will explore the top skills required for a React Native developer, including a solid understanding of JavaScript, experience with React and Redux, proficiency in native modules and APIs, and a strong sense of UI/UX design. 

Whether you’re just starting out or looking to upgrade your existing skill set, this guide will provide a comprehensive overview of what it takes to be a top-performing React Native developer.

What is React Native?

React Native is a JavaScript-based framework for building native mobile applications

for iOS and Android platforms. 

It was developed by Facebook and allowed developers to create high-quality, performant mobile apps that feel and look like traditional, natively-built apps. 

React Native uses a single codebase, enabling developers to write code once and run it on multiple platforms, reducing development time and cost. 

The framework is built upon Facebook’s React JavaScript library, which provides a flexible and efficient way to manage the user interface and user interactions in mobile apps.

Features of React Native platform

• Cross-platform compatibility: React Native allows developers to build apps for both iOS and Android platforms using a single codebase.

• Native performance: React Native uses native components to deliver high-performance apps that look and feel like native apps.

• Hot Reloading: React Native supports hot reloading, which allows developers to see changes in real time without restarting the app.

• JavaScript: React Native uses JavaScript, a popular and widely-used programming language, making it easier for web developers to transition to mobile app development.

• Community support: React Native has a large and active community of developers who contribute to the development of the framework and its libraries.

• Native Modules: React Native provides a way to access native functionality using native modules, which are collections of native code and can be used in React Native apps.

• Reusable components: React Native enables developers to reuse components across different platforms, reducing development time and effort.

• Flexible architecture: React Native has a flexible architecture that allows for custom styling, animations, and interactions.

• Third-party libraries: React Native has a large number of third-party libraries and tools available for use, making it easier to add functionality to your app.

• Native-like experience: React Native provides a native-like experience for users, with fast and smooth animations, gesture support, and access to native device functionality.

Who is a React Native Developer?

A React Native Developer is a software engineer who specializes in developing mobile

applications for iOS and Android platforms using the React Native framework.

Roles and responsibilities of React Native Developer

The roles and responsibilities of a React Native Developer typically include the following:

• Designing, developing and maintaining high-quality mobile apps for iOS and Android platforms using the React Native framework.
• Writing clean, maintainable and efficient code that meets the requirements of clients or end-users.    
• Collaborating with cross-functional teams to define, design, and ship new features.
• Debugging and fixing issues and bugs in the mobile app.
• Participating in code reviews to maintain the quality of the codebase.    
• Staying up-to-date with the latest trends and technologies in mobile development.      
• Implementing new technologies and techniques to improve app performance and user experience.      
• Mentoring junior developers and contributing to the development community through knowledge sharing.    
• Participating in the entire app development life cycle from concept to deployment.     
• Ensuring the quality of the code by conducting unit tests,integration tests and regression tests.
• Communicating project progress and deliverables to stakeholders.
• Creating technical documentation for the mobile app.

Note: The specific responsibilities of a React Native Developer may vary depending on the

size and nature of the organization they work for and the project requirements.

What are the essential technical skills of a React Developer? 

6 Reasons To Use React Development Tools

The essential technical skills of a React Developer include the following:  

• Strong knowledge of JavaScript: A React Native developer should have a deep understanding of JavaScript, including its syntax, data structures, and programming concepts.

• Familiarity with React: React is the core library that powers React Native, so a strong understanding of React is essential for developing mobile apps using the framework.

• Experience with Redux: Redux is a popular state management library used in many React

• Proficiency in Native Modules and APIs: A React Native developer should have experience working with native modules and APIs to access the functionality of the device’s hardware and operating system.

• Strong sense of UI/UX design: A React Native developer should have a good understanding of UI/UX design principles and the ability to build user-friendly and visually appealing mobile apps.

• Familiarity with mobile development patterns: Understanding common mobile development patterns, such as navigation, data storage, and async programming, is important for developing high-quality mobile apps.

• Knowledge of Git: Git is a version control system used by many development teams. A React Native developer should be familiar with using Git for version control and collaboration.

• Experience with mobile testing: Testing is a critical component of mobile app development, so a React Native developer should have experience testing mobile apps for bugs and performance issues.

• Familiarity with native development tools: A React Native developer should be familiar with the development tools used for building native mobile apps, such as Xcode and Android Studio.

•  Knowledge of app deployment and distribution: A React Native developer should have experience deploying mobile apps to app stores and distributing them to users. They should also be familiar with the app store submission process, including certification and review processes.

Image: Essential skills for a React Developer  

Which tools should you be familiar with React Developer?

Familiarity with certain tools is essential for a React developer, but the expertise requirement may vary depending on the project scope and the preferences of the development team.  

Must-have React Development Tools

It’s important to continuously learn and improve your skills in these and other related tools.

• React: The core library for building user interfaces using React.
• React Developer Tools: A browser extension for debugging and inspecting React components and their state.
• Redux: A popular state management library used with React.
• Webpack: A module bundler for JavaScript applications.
• Babel: A JavaScript compiler that allows you to write modern JavaScript and transpile it to older versions supported by older browsers.
• Npm or Yarn: Package managers for JavaScript libraries and tools.
• Git: A version control system for tracking changes in your code.
• Chrome DevTools: A set of developer tools built into Google Chrome for debugging and optimizing websites.
• Jest or Mocha: JavaScript testing frameworks for writing and running tests for your React components and applications.
• Visual Studio Code: A popular code editor for writing React applications.

What Soft Skills Should You Have as a React Developer?

Soft skills are often just as important as technical skills in determining a React developer’s success. It’s important to continuously develop and improve your soft skills in addition to your technical skills.

• Communication skills: React developers need to be able to communicate effectively with other members of the development team, stakeholders, and clients.

• Problem-solving skills: React developers need to be able to identify and solve problems quickly and effectively, both independently and as part of a team.
• Teamwork skills: React developers need to be able to work well with others, collaborate effectively, and support their team members.
• Adaptability: React developers need to be able to adapt to new technologies and changing requirements and be open to learning new skills.  
• Attention to detail: React developers need to be meticulous and pay close attention to detail to ensure the quality of their work.
• Time management skills: React developers need to be able to manage their time effectively and prioritize tasks to meet deadlines.
• Creativity: React developers need to be able to think creatively and come up with innovative solutions to complex problems.
• Proactive: React developers need to be proactive, take initiative, and be willing to take ownership of their work.
• Flexibility: React developers need to be flexible and able to work on multiple projects and tasks simultaneously.
• Passion for technology: React developers should have a passion for technology and a desire to continuously improve their skills and knowledge.

Wrapping Up

In conclusion, being a React Native developer is an exciting and rewarding journey. With React Native, you have the power to create beautiful, high-performance mobile apps that reach millions of users. 

The framework provides an array of tools and features that make it easy to build cross-platform apps that deliver a native-like experience. But, as a React Native developer, it’s not just about technical skills and expertise. It’s also about having the right mindset, approach, and personal qualities to succeed. 

Whether you are new to the world of mobile development or an experienced pro, the key to success is a continuous thirst for learning and growth.

Finally, always keep in mind that the tech industry is constantly evolving, so it’s crucial to stay up-to-date with the latest developments and trends in React Native to stay ahead of the curve.

The post Essential Skills For A React Native Developer in 2023 appeared first on Talent500 blog.

If you’re choosing a framework for Android, iOS, and Windows app development, Xamarin has many advantages to offer.

Advantages of Xamarin:

The fact that Xamarin is so well-known is one of its greatest advantages. One of the earliest cross-platform development frameworks available, Xamarin was developed in 2011 and has roots in the open-source Ximian and Mono projects.

Due to the extensive use of Xamarin and.NET in the development of apps over a lengthy period of time, the procedure has been well-honed. More than a million people worldwide have downloaded the Xamarin software development kit since it was officially adopted into the.NET ecosystem by Microsoft in 2016 and acquired by the tech giant.

It is simple to understand why: Xamarin enables developers to use.NET and C# to create native apps that avoid the overhead of certain competing frameworks and provide high speed. Through a single application programming interface, the Forms framework offers a mechanism to guarantee a uniform appearance across devices (API).

Xamarin is available when platform-specific APIs are needed.

A cross-platform API called Essentials provides translation for functions including sensor access, geolocation, device statistics, and safe storage. Additionally, even while Xamarin focuses on mobile development for Android and iOS devices, it enables developers to share the underlying code with any.NET-compatible platform, such as Windows, macOS, Linux, and others.

The list of businesses that have used Xamarin to create widely-used applications is impressive as well. UPS’ mobile app, which includes integrated automated customer service bot functionality, was created on the platform; JustGiving, an online platform for charitable donations, uses Xamarin for its Android and iOS apps; and Microsoft itself uses Xamarin for its Seeing AI app, which increases accessibility by narrating the environment to a visually-impaired smartphone user.

While larger businesses will need to purchase Microsoft’s Visual Studio development environment, Xamarin is also entirely free to use for individual developers, early-stage startups, and smaller businesses. But by doing this, developers are ensured of a usable and well-supported development environment thanks to Microsoft’s backing.

Disadvantages of Xamarin:

Before starting to develop cross-platform apps with Xamarin, there are some drawbacks to be aware of, and the aforementioned license needs, which may pile up for larger businesses, are only one of them.

Although Xamarin is one of the more established cross-platform development frameworks, it has been overtaken by more recent entrants. According to a 2021 Statista developer poll, the two most popular, Flutter and React Native, are utilized by 42% and 38% of framework-assisted cross-platform mobile app developers, respectively; Xamarin is used by only 11% of developers.

When it comes time to expand your team for additional development or application maintenance, a less well-known framework may make it more difficult to locate the employees with the capabilities you require. However, because Xamarin has been around for a longer period of time, the staff that is currently accessible is usually more experienced, so any difficulties you may have in obtaining entry-level employees may be offset by the ease with which you can locate senior-level engineers.

Many of Xamarin’s rivals have expanded beyond mobile, making it possible to deploy apps for both mobile and desktop using a single codebase. But Xamarin continues to prioritize mobile.Nothing in Xamarin is aimed specifically for desktop platforms. However, because of its integration into.NET, it may be possible to share up to 75% of a codebase between mobile and desktop. You’ll still require two development branches, but they don’t have to be distinct from one another.

The.NET MAUI framework, which Microsoft describes as “the evolution of Xamarin,” has also just been released with Visual Studio. Using C# and XAML in a single codebase, MAUI is a new framework for creating contemporary, cross-platform, natively built apps for iOS, Android, macOS, and Windows. In the upcoming months, Socket Mobile will formally enable MAUI development and continue to offer the resources programmers require to make high-performance applications.

Picking a framework/Conclusion:

When it comes to creating mobile apps, Xamarin has a lot to offer, especially if you want to avoid coding for each platform separately while still targeting a variety of operating systems and platforms. The benefits of the flexibility and scalability it may provide to projects should not be underestimated, despite the fact that it has some drawbacks.

In some situations, Xamarin is the only sensible option for a framework for cross-platform mobile apps. If you already work in the.NET ecosystem, Xamarin allows you to start developing right away without having to learn anything completely new—and in the familiar setting of Visual Studio, no less.

If you are looking for challenging opportunities at some of the fastest-growing global companies, join Talent500. Sign up here.

The post Android and iOS apps with Xamarin appeared first on Talent500 blog.

Install redux

If you cloned the repo from the previous example, check that the package’s dependencies are correct. The json file looks like this:

“dependencies”: {
“@react-native-community/masked-view”: “0.1.5”,
“expo”: “~36.0.0”,
“react”: “~16.9.0”,
“react-dom”: “~16.9.0”,
“react-native”: “https://github.com/expo/react-native/archive/sdk-36.0.0.tar.gz”,
“react-native-gesture-handler”: “~1.5.0”,
“react-native-paper”: “3.4.0”,
“react-native-reanimated”: “~1.4.0”,
“react-native-safe-area-context”: “0.6.0”,
“react-native-screens”: “2.0.0-alpha.12”,
“react-navigation”: “4.0.10”,
“react-navigation-stack”: “2.0.10”,
“react-redux”: “7.1.3”,
“redux”: “4.0.5”
},

To integrate and manage the state with Redux, now install the following dependencies from a terminal window.
yarn add redux react-redux lodash.remove

The directory structure used to organise Redux-related files will be based on the pragmatic method known as ducks. The duck’s design enables the use of modular reducers within the app itself. There is no need to create separate files for actions, types, and action creators. Instead, declare them all in a single modular file; however, if more than one reducer is required, specify several reducer files.

Adding creators and action types

When utilising Redux to manage the overall state of the application, the state is represented by a single JavaScript object. Think of this object as read-only, since you cannot make changes to this state directly. It requires actions to do so.

In Redux, actions are analogous to events. They can be activated by button presses, timers, or network requests.

To begin, establish a subfolder named redux under the src/ directory. Create a new file named notesApp.js within it.

Thus far, the programme allows the user to add notes. Let’s start by creating two action kinds and their creators in the newly generated files. The user will be able to remove an item from the ViewNotes screen using the second action type.

// Action Types
export const ADD_NOTE = ‘ADD_NOTE’
export const DELETE_NOTE = ‘DELETE_NOTE’

Next, for each action type, define action creators. The first will be triggered when the note is saved, and the second will be triggered when the note is deleted.

// Action Creators
let noteID = 0
export function addnote(note) {
  return {
    type: ADD_NOTE,
    id: noteID++,
    Note
  }
}
export function deletenote(id) {
  return {
    type: DELETE_NOTE,
    payload: id
  }
}

Adding a reducer

A reducer is who receives the action. The application’s state changes whenever an action is performed. The reducers are in charge of managing the application’s state.

A reducer is a pure function that determines the future state depending on the previous or starting state. If the state remains unaltered, it always returns the same result. It accepts two inputs (state and action) and must return the default state.

The initial state will be an empty array. When you’ve specified action creators, add the following. Likewise, at the top of the notesApp.js file that was installed at the start of this post, import the remove tool from the lodash.remove npm package:

// import the dependency
import remove from ‘lodash.remove’
// reducer
const initialState = []
function notesReducer(state = initialState, action) {
  switch (action.type) {
    case ADD_NOTE:
      return [
        …state,
        {
          id: action.id,
          note: action.note
        }
      ]
  case DELETE_NOTE:
      const deletedNewArray = remove(state, obj => {
        return obj.id != action.payload
      })
      return deletedNewArray
    Default:
      return state
  }
}
export default notesReducer

Configure a Redux store

A store is an object that connects actions and reducers. It delivers and maintains state at the application level rather than at the level of individual components. Redux does not have an opinion about which framework or library should utilise it.

When you’ve finished creating the reducer, add a new file named store.js to the src/redux/ directory. Import the function createStore from redux, as well as the app’s only reducer for the time being.

import { createStore } from ‘redux’
import notesReducer from ‘./notesApp’
const store = createStore(notesReducer)
export default store

Open the entry point file App.js and import the store as well as the react-redux npm package’s high order component (HOC) Provider to link this Redux store to the React Native app. This HOC assists you in passing the store down to the other components of the current app.

import React from ‘react’
import { Provider as PaperProvider } from ‘react-native-paper’
import AppNavigator from ‘./src/navigation’
import { Provider as StoreProvider } from ‘react-redux’
import store from ‘./src/redux/store’
// modify the App component
export default function App() {
  return (
    <StoreProvider store={store}>
      <PaperProvider>
        <AppNavigator />
      </PaperProvider>
    </StoreProvider>
  )
}

That’s all! The Redux store is fully set up and ready to go!

Accessing global state

The useSelector Hook is given to access state while managing it using Redux. It’s analogous to the mapStateToProps parameter supplied by connect (). It lets you use a selector function to pull data from the Redux store state.

The major difference between the Hook and the argument is that the selector may return any value as a result, not just an object.
1. Open the ViewNotes.js file
2. Import this Hook from react-redux

// …after rest of the imports
import { useSelector } from ‘react-redux’

Next, inside the ViewNotes functional component, instead of saving a notes array with the useState Hook, replace it with the following:

const notes = useSelector(state => state)

Dispatching actions

The useDispatch() Hook entirely refers to the Redux store’s dispatch function. This Hook is only used when an action has to be sent. Import it from react-redux, along with the addnote and deletenote actions from the redux/notesApp.js file.

import { useSelector, useDispatch } from ‘react-redux’

After the useSelector Hook, define the following sentence to dispatch an action:

const dispatch = useDispatch()

Next, to trigger these events, dispatch two operations named addNote and deleteNote:

const addNote = note => dispatch(addnote(note))
const deleteNote = id => dispatch(deletenote(id))

Because the naming convention for the addNote action is identical to that of the previous post’s helper function, there is no need to make any modifications inside the functional component’s return statement for this. But, the deleteNote action is brand new.

Add a prop onPress to List to remove a note from the displayed list. React-native-paper item UI component. This will provide the capability of removing an item from the list when the user touches it.

Below is the code snippet of List.Item component with changes. Also, ensure to modify the values of props: title and description.

<List.Item
  title={item.note.noteTitle}
  description={item.note.noteValue}
  descriptionNumberOfLines={1}
  titleStyle={styles.listTitle}
  onPress={() => deleteNote(item.id)}
/>

The advantage of  useDispatch hook is that it replaces mapDispatchToProps. Also it is not required to write boilerplate code to bind action creators with this hook now.

Conclusion

Other hooks like useDispatch and useSelector Redux not only minimise the need to create a lot of boilerplate code, but they also give the benefits of utilising functional components. Hence, while redux assists us in managing application state, this does not imply that you should use Redux in all of your projects. Other methods for handling state in our application include react-context, mobx, and libraries. But, before diving into the Redux components, it’s a good idea to brush up on your application development fundamentals. If the app state is regularly updated, and the logic to update that state is complicated, you might consider utilising redux. The programme has a medium or big codebase and may be worked on by a large number of individuals. You must examine how that condition changes throughout time.

The post How to Use Redux with React Hooks in React Native Application appeared first on Talent500 blog.

Google introduced deep linking for android development as a way for applications to gather data inside the database as a URL link. If you are an android developer, it’s essential to understand how deep linking and android functions. This article explores the implementation of deep links in an android app.

What is a deep Link?

A deep Link is a URL generated by the application based on the user’s past behavior. The app opens with a specific activity or screen when the user clicks on the deep link. We can customize the deep Link URL to send a message to applications with predefined parameters. For example, using a deep link in WhatsApp, we can create a URL that sends a specific message to a phone number when the link is correct. Deep links are useful in providing direct access to specific screens or tasks of an application with a URL link.

How to create deep links? 

A practical implementation of deep link can be a simple application that displays a particular message when the URL is clicked. Here is a video of the working example:

https://media.geeksforgeeks.org/wp-content/uploads/20210128101827/Screenrecorder-2021-01-28-10-14-37-248.mp4

To create a new project in Android Project, refer to this article on How to Create New Project in Android Studio. The code can be implemented in both Java and Kotlin programming languages for Android.

Step 1: Create an activity_main.xml file 

The first step is to create an activity_main.xml for your android project. You can use Java or Kotlin programming language for this example.

The activity_main.xml code will be like this:

<?xml version=”1.0″ encoding=”utf-8″?>

<RelativeLayout

    xmlns:android=”http://schemas.android.com/apk/res/android”

    xmlns:tools=”http://schemas.android.com/tools”

    android:layout_width=”match_parent”

    android:layout_height=”match_parent”

    android:orientation=”vertical”

    android:weightSum=”5″

    tools:context=”.MainActivity”>

    <!– text view for displaying welcome message –>

    <TextView

        android:id=”@+id/idTVWelcome”

        android:layout_width=”match_parent”

        android:layout_height=”wrap_content”

        android:layout_centerInParent=”true”

        android:padding=”10dp”

        android:text=”Welcome to “

        android:textAlignment=”center”

        android:textAllCaps=”false”

        android:textColor=”@color/purple_500″

        android:textSize=”30sp” />

    <!– text view for displaying the organization

        name from the link which we have generated –>

    <TextView

        android:id=”@+id/idTVMessage”

        android:layout_width=”match_parent”

        android:layout_height=”wrap_content”

        android:layout_below=”@id/idTVWelcome”

        android:text=”Organization Name”

        android:textAlignment=”center”

        android:textAllCaps=”false”

        android:textColor=”@color/purple_500″

        android:textSize=”30sp”

        android:textStyle=”bold” />

</RelativeLayout>

Step 2: Create an AndroidManifest.xml file

The next step is to create an AndroidManifest.xml file because we will add a deep link to the MainActivity file. Pay attention to the comments to understand what the code does: 

<?xml version=”1.0″ encoding=”utf-8″?>

<manifest xmlns:android=”http://schemas.android.com/apk/res/android”

package=”com.example.deeplinks”>

<application

android:allowBackup=”true”

android:icon=”@mipmap/ic_launcher”

android:label=”@string/app_name”

android:roundIcon=”@mipmap/ic_launcher_round”

android:supportsRtl=”true”

android:theme=”@style/Theme.DeepLinks”>

<activity android:name=”.MainActivity”>

<intent-filter>

<action android:name=”android.intent.action.MAIN” />

<category android:name=”android.intent.category.LAUNCHER” />

</intent-filter>

<!– as we want to open main activity from our link so we are specifying

only in main activity or we can specify that in different activity as well –>

<!– on below line we are adding intent filter to our MainActivity –>

<intent-filter>

<!– below line is to set the action to our intent to view –>

<action android:name=”android.intent.action.VIEW” />

<!– on below line we are adding a default category to our intent –>

<category android:name=”android.intent.category.DEFAULT” />

<!– on below line we are adding a category to make our app browsable –>

<category android:name=”android.intent.category.BROWSABLE” />

<!– on below line we are specifying the host name and

the scheme type from which we will be calling our app –>

<data

android:host=”www.chaitanyamunje.com”

android:scheme=”https” />

</intent-filter>

<!– below is the same filter as above just the scheme is changed to http –>

<!– so we can open our app with the url starting with https and http as well –>

<intent-filter>

<action android:name=”android.intent.action.VIEW” />

<category android:name=”android.intent.category.DEFAULT” />

<category android:name=”android.intent.category.BROWSABLE” />

<data

android:host=”www.chaitanyamunje.com”

android:scheme=”http” />

</intent-filter>

</activity>

</application>

</manifest>

Step 3: Configure the MainActivity File

Finally, we will make changes to the MainActivity File in Java or Kotlin language as follows: 

import android.net.Uri;

import android.os.Bundle;

import android.widget.TextView;

import androidx.appcompat.app.AppCompatActivity;

import java.util.List;

public class MainActivity extends AppCompatActivity {

// creating a variable for our text view

private TextView messageTV;

private Uri uri;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

// initializing our variable

messageTV = findViewById(R.id.idTVMessage);

// getting the data from our intent in our uri.

uri = getIntent().getData();

// checking if the uri is null or not.

if (uri != null) {

// if the uri is not null then we are getting

// the path segments and storing it in list.

List<String> parameters = uri.getPathSegments();

// after that we are extracting string

// from that parameters.

String param = parameters.get(parameters.size() – 1);

// on below line we are setting that string

// to our text view which we got as params.

messageTV.setText(param);

}

}

}

The output 

As you run the app, you will be greeted by a screen for the organization’s name. Now close the application and click on the link “https://www.chaitanyamunje.com/hello/GeeksForGeeks.” A pop-up will appear, asking you to select the application. Inside the pop-up, select the application you just created. The message “GeeksForGeeks” will be displayed in place of the Organization name.

When to use deep links?

Deep links produce a seamless user journey that increases the likelihood of app installation. Users are directed to the installation page with a single click. These links are also useful in creating app content that makes incentivizing easier. Companies use deep links to increase conversion rates and retention rates.

Conclusion 

In android development, deep links play an important role in improving user experience. We hope this guide on deep linking and android will help you anticipate the importance of the concept for improving your mobile development skills.

Talent 500 is a distributed team-building platform for Fortune 500 companies and fast-growing start-ups. Sign up here to learn more.

The post Introductions to deep linking in Android appeared first on Talent500 blog.

Gradle and Maven are the first two names that come to mind when thinking about creating automation tools. Both of these build automation technologies utilize a build script to automatically convert the source code into machine code. In this article, we’ll compare Maven vs Gradle to see which one could work better for your project.

What is Maven ?

Maven is a tool for managing projects that deals with distribution, releases, builds, and dependencies. A software build in this context refers to the procedure used to turn source code into a standalone form that can be executed on a computer.

Maven also enables team collaboration, documentation, distribution, and compilation. A directory of packed JAR files with pom.xml files is also included in the Maven repository. It possesses the configuration data necessary to complete the project. JAR refers to a package in this context that unifies various Java class files and associated resources into a single file for distribution.

Additionally, Maven dependencies are present in the repository. Local, central, and remote repositories are the three types. Maven looks through the local repository first, followed by the central and remote repositories. On the computer is a local repository. Central and distant repositories are available online, nevertheless. Maven simplifies the creation and management of projects overall.

Features of Maven ?

1. Simple project setup that adheres to industry standards.
2. Consistent usage across all projects.
3. Dependency management, including automated upgrading.
4. A huge and expanding collection of libraries.
5. It is extensible and makes it simple to create plugins in Java or scripting languages.
6. New features are immediately available with minimal or no additional configuration
7. Model-based builds – Maven may build any number of projects into output kinds that have already been predetermined, like jar, war, and metadata.
8. Coherent site of project information − Using the same metadata as the build process, maven may produce a website and a PDF with comprehensive documentation. 
9. Release management and distribution publication − Maven will automatically integrate with your source control system, such as CVS, and manage a project’s release without any additional configuration.
10. Backward Compatibility − Multiple modules of a project can be readily transferred from Maven 2 to Maven. It can also support earlier versions.
11. Automatic parent versioning − In the sub module, the parent does not need to be specified for maintenance.
12. Parallel builds − It allows you to create schedule modules in parallel and examines the project dependency tree. You can gain performance improvements of 20–50% using this.
13. Better Error and Integrity Reporting − Maven enhanced error reporting and gives you a link to the Maven wiki page where you may find a detailed explanation of the mistake.

Advantages of Maven ?

1. Building a project is an easy and well-organized procedure.
2. The process of getting Jar files and other dependencies is carried out automatically by Maven.
3. By writing the dependent code in the POM file, Maven may quickly add new dependencies.
4. It makes it simple to access all the important data.
5. It is easily extendable, and plug-ins written in Java and other scripting languages are simple to create.

Disadvantages of Maven ?

1. Installation is required on a functioning system.
2. If the Maven code for an existing dependence cannot be retrieved, we cannot implement a dependency using Maven.
3. Maven is a very slow project execution tool.

What is Gradle ?

An open source build automation system is called Gradle. It makes use of Apache Ant and Apache Maven principles. Its main purpose was to support builds that included several projects. Whereas Gradle utilizes a Directed Acyclic Graph to decide the order in which to execute the jobs. Within a short time, Gradle gained popularity. For instance, Google made Gradle the standard build tool for the Android OS.

Additionally, Gradle is built on the DSL platform (Domain Specific Language). It doesn’t employ XML. because it was created to address a particular issue. Additionally, it enables the entire software life cycle, from compilation to testing and statistical analysis to packaging and deployment.

Gradle also has a number of benefits. It enables the build process to incorporate typical design principles. It aids developers in creating well-organized, maintainable builds for various projects. It also offers a variety of methods for managing dependencies.

Gradle resolves all the issues faced on other build tools like Maven and ANT. The tool focuses on:

• Maintainability
• Usability
• Extendibility
• Performance
• Flexibility

Features of Gradle ?

1. Declarative builds and build-by-convention – 

1.1. There is a separate Domain Specific Language (DSL) for Gradle that is based on the Groovy language. It offers the components of declarative language. 

1.2. These components also offer Java, Groovy, OSGI, Web, and Scala build-by-convention compatibility.

1. Language for dependency based programming – The declarative language lies on top of a general purpose task graph, which can be fully supported in the build.

2. Structure your build – You can use Gradle to incorporate common design ideas into your build. It will provide you with the ideal framework for your construction so that you may plan a clear, easily maintained and comprehensible build.

3. Deep API –  By using this API, you can monitor and customize its configuration and execution behavior to the core.

4. Gradle scales – From small, single-project builds to massive, enterprise-wide multi-project builds, Gradle may effectively enhance productivity.

5. Multi-project builds – Both multi-project builds and partial builds are supported by Gradle. Gradle takes care of building all the dependent subprojects when you build a subproject.

6. Different ways to manage your builds – Gradle supports different strategies to manage your dependencies.

7. Gradle is the first build integration tool – For your ANT tasks, Maven, and ivy repository architecture for publishing and retrieving dependencies, Gradle is fully supported. Additionally, a converter for converting a Maven pom.xml to a Gradle script is included.

8. Ease of migration – Gradle can easily adapt to any structure. Therefore, you can always develop your Gradle build in the same branch, where you can build a live script.

9. Gradle Wrapper – Gradle Wrapper allows you to execute the Gradle builds on machines, where Gradle is not installed. This is useful for continuous integration of servers.

10. Free open source – Gradle is an open source project, and licensed under the Apache Software License (ASL).

11. Groovy – The build script for Gradle is created in the Groovy programming language. Gradle was created with the intention of being used as a language rather than a strict framework. You can create your own script using Groovy and some abstractions. The whole Gradle API is fully designed in Groovy language.

Why choose Groovy for Gradle ?

The Groovy programming language is used to create the whole Gradle API. An internal DSL has this advantage over XML. Gradle is a multifunctional build tool with a primary focus on Java projects. As a result of the team members’ extensive Java experience, it is preferable for a build to be as clear as possible to everyone on the team.

The best languages for building frameworks are Python, Groovy, or Ruby. Groovy was chosen because it provides Java users with the best level of transparency by a wide margin. Groovy and Java have a similar fundamental grammar, but Groovy offers a lot more advantages to consumers.

Advantages of Gradle ?

1. Its highly customizable feature. The tool is adaptable to several technologies and tasks.
2. Gradle operates in a quick and effective manner. It is roughly twice as fast as Maven.
3. Gradle is a versatile instrument used for plug-in development.
4. It offers a large selection of IDEs for an improved user experience.

Disadvantages of Gradle ?

1. Using Gradle to construct tasks requires a high level of technical knowledge.
2. It lacks an inbuilt ant project framework.
3. Gradle’s documentation is fairly comprehensive.
4. XML is to be used to create Ant build scripts. A significant amount of logic must also be written in XML files in order to automate a challenging job.

Differences between Maven and Gradle ?

Choose between Maven and Gradle ?

We are aware that Gradle and Maven each offer a unique set of benefits and drawbacks. Without a doubt, Gradle is the more potent of the two tools. Nevertheless, it includes a lot of functionalities that aren’t always necessary, and managing a lot of functionalities is a little challenging.

Maven excels at handling small projects. It should be used when conventions (rather than Configuration) are preferred, along with dependency management, modularization, consistency, and lots of plug-ins.

Gradle is excellent for large projects. When adaptability, simplicity, speed, and incremental builds are crucial, we ought to employ it.

Conclusion :

You should be familiar with the fundamentals of both Maven and Gradle by this point. In the Maven vs. Gradle comparison, we saw a number of aspects that might be decisive. You can select the build tool that is more appropriate for your software with the aid of the differences.

In a nutshell, the key distinction between Maven and Gradle is that Maven is an open source build automation tool with a performance and flexibility focus, while Gradle is a build management and comprehension tool that controls project builds, reports, and documents.

The post GRADLE AND MAVEN IN ANDROID appeared first on Talent500 blog.

Ace your next Android interview with this ultimate guide

Android is an open-source and Linux-based Operating System for mobile devices such as smartphones and tablet computers. The source code for Android is available under free and open-source software licenses. 

Future of Android Developers

Nowadays, mobile app development is a booming sector. 
Anyone can have this very question “What is the future of Android Developers? Is Android Developer a good career option?” So you should know that there are more than 2.5 billion active android users, plus more than 3 million apps are available on Google Play Store. Isn’t that a big deal?
Users spend 90% of their time on applications while using their phones, telling us that our phones are no longer just phones; instead, they are our windows to the outside world.

There is no doubt that Android Developers will always be in demand. Android developers will undoubtedly have the upper hand and a bright future.
Check the following link out to get in-depth insight into Mobile App Development of the future.

Top Essential Skills for Android Developers

1. Android Foundations
2. Android UI
3. API Integration
4. Proficiency in Database Technologies
5. Coding Architectures like (MVVM, MVP, Clean Architecture, and MVVM Use Cases)
6. Android Testing
7. Android Security
8. Cross-Platform App Development
9. Version Control System: Git and GitHub/BitBucket/Gitlab
10. Strong Communication Skills

Tips to crack your next Android Interview

Tip 1: Make your foundation strong in Android and strengthen your Java or Kotlin programming concepts.

Tip 2: Know your resume well
Each of us can have a unique resume based on our education, skills, and work experience. The interviewer can ask you any technical questions about the skill/technology that you have mentioned in your resume. 
So the key here is to brush up or revise what you have worked on. 

Tip 3: While preparing for technical questions, focus on the  what, the why and the how.
So if an interviewer asks you about a room database or retrofit manager, you should be able to tell what it is and what problems it solves, and how it helped your customers and users achieve their business goals. This should come last in your answer. 

Later if time permits or the interviewer likes you to explain more about this you will talk about how to implement a particular feature in your app because both you and the interviewer know that how to integrate something can be easily googled, and steps for it keep changing from time to time.

So let’s take less priority as compared to what and why of a particular technology. 

Tip 4: Be prepared to answer commonly asked android interview questions.
At the end of this article, I have listed the most important and commonly asked Android interview questions. Prepare for them and brush up on your android skills and projects.

Tip 5: Prepare to describe the apps that you have worked on.
Be confident in explaining the projects that you have mentioned in your resume. Not just technically, but also from a layman’s perspective. Describe what the app is about and who its target users are. 

You should be able to describe the features of the app and your contribution as a developer for it. Explain the efforts y0u had put in and the work you did clearly to the interviewer.

Tip 6: Be ready with an android app as a demo you have released on the Google Play Store.

Tip 7: Keep yourself updated on Android’s latest trends and technologies.
The best way to be updated with Android technology is to follow people who are into Android Development on different social media platforms like Twitter, LinkedIn and YouTube. Consume their quality content to expand your skill set in android and keep updated yourself with new technologies.

Tip 8: Learn Modern Android Development (MAD) skills to stand out from other candidates appearing for the same interview.
MAD will help you use the latest android technologies to create more scalable and better android applications. 
Watch a series of videos and articles Google created to teach you how to use the latest technologies of Modern Android Development to create better applications more easily.

Tip 9: Work on your Communication Skills.
Try to best answer the questions of your interviewer with confidence and appropriate body gestures. 

Tip 10: Spend some good amount of time learning Android Best Practices.
Learn the dos and don’ts that will help you become a better developer and help your app stand out from the rest.

Here is the compilation of some of the best practices for you to make better android apps. You should be in a position to communicate effectively with your senior developers, colleagues once you start working in a team. There is no doubt that people with good communication skills are preferred during job interviews. 
Attend dev meet-ups and be more social with other developers around you. Interact more with other developers and you will get to learn a lot from them.

What does it mean to be an industry-ready android developer? 

Before applying for a job, you should consider some things. Of course, most importantly, you should be able to build some basic apps. 
You should be able to interact with remote APIs, use local databases, and feel confident with different architectures like MVVM and Clean Architecture. 
Apart from that, don’t forget your soft skills. It definitely makes sense to sit down and think about before an interview how you can best sell these skills in front of an interviewer.

This is what companies ask in android interviews

Should you become an expert in data structures and algorithms to actually nail your android interviews? 
No, luckily not as long as you are not applying at big tech. In my experience, companies usually ask for things like android architecture, android-specific things like the activity lifecycle, dealing with local databases and APIs, Kotlin code style, async programming with coroutines and flows, viewmodels and LiveData working, and so on. 
You really don’t need to worry about such interviews if you are actually able to build simple, solid apps with common practices.

Moving further let’s take a look at some important topics that companies usually ask in android interviews.

List of top Android Interview questions

1. Explain the Android Application Architecture.
2. What is Android Runtime?
3. Explain DDMS in brief.
4. What are SOLID Principles?
5. What are the core building blocks of android?
6. What is the Android Manifest?
7. What is the APK format?
8. What is the difference between Fragment and Activity?
9. What is Gradle and why is it important in android?
10. How does Garbage Collector work in android?
11. Explain different data storage options available on android.
12. MVVM or MVVM Use Cases, which one should we use?
13. What is the difference between MVP and MVVM?
14. Explain Clean Architecture in android?
15. Describe the app architecture that you have used in your recent app.
16. How will you prevent frequent app crashes? Which troubleshooting techniques will you use for that?
17. How do you prevent memory leaks in the android app?
18. Explain different Launch Modes in android.
19. Explain about ProGuard.
20. What is Kotlin Coroutine in Android?
21. What are the new Kotlin features that you are aware of?
22. Explain Android KTX.
23. What are different ways to boost your android app’s performance?
24. What is Android JetPack?
25. What are the key benefits of using JetPack Compose?
26. What is an app’s state and how the state is managed in JetPack Compose applications?
27. Explain Composition and Recomposition in android.
28. Explain the Core UI elements of JetPack Compose.
29. Explain Navigation Stack and Navigation Graph in Compose.
30. What JetPack Compose libraries have you used?
31. Explain ViewModel in android.
32. What is the difference between ViewModel and AndroidViewModel?
33. Explain LiveData in android.
34. Explain Singleton Design Pattern in android.
35. What are the benefits of using Kotlin over Java?
36. Throw some light on how you can handle app lifecycle using Lifecycle-aware Components in android.
37. Why should we use a Mockito library?
38. Explain Unit & Instrumentation tests.
39. Why do we need an Emulator/Simulator?
40. What are the features that can’t be tested on an Emulator/Simulator?
41. Explain UI testing in android.
42. What are Product Flavors and how are they created in android?
43. What is Dagger Hilt and when to use Dagger Hilt?
44. What is Dependency Injection in android?
45. Explain an API that you have come across recently.

That’s a wrap for this article. Best of luck on your next interview!

The post Android Interview Preparation Checklist appeared first on Talent500 blog.

A list of the 10 best backend frameworks for mobile app development should be the best place to start. For frontend, you can check our blog post for essential tools for faster frontend development. In this blog, we will not only cover and explore what backend development is and what the top backend frameworks are, but also how these frameworks would impact your mobile app development project. 

What is a mobile app backend?

The mobile app backend framework is the backbone of your app and lives on the server. It helps create and manage all essential services in the background function of a mobile or web app. A database, web server, operating system, framework, and server-side languages such as Python, PHP,.Net, Swift, Objective-C, JavaScript, Ruby, Kotlin, C#, C++, GO, and Dart are examples of back-end components.

Best Mobile App Backend Framework in 2022-23

According to Statista, smartphone users are expected to reach 7.5 billion by 2026.

Following these expectations, mobile app development has become one of the most profitable business opportunities in recent years. Many developers are seeking the best framework to build their mobile apps, due to the growing demand for them. To address their challenges, in this section we will discuss the most popular framework for mobile backend development, and how it can help you build apps with its amazing features and functionalities.

 Here is the list of the best mobile app backend frameworks for 2022–2023.

1.NodeJS

NodeJS is the most popular backend framework for mobile app development. It is a cross-platform, server-side JavaScript environment that can be used to build scalable and high-performance web applications. It has an extensive collection of modules that can be used to build applications, and it’s also fast, scalable, and lightweight.

NodeJS was created by Ryan Dahl and TJ Holowaychuk, who were looking for a way to create their own server-side scripting language. With Node JS, developers are able to write JavaScript on both the client and server sides. In real-time applications, this enables data transfer between the server and the client, thereby enabling synchronisation.

Features of NodeJS include: 

1. Suitable for cross platform mobile applications development 
2. Easier development process
3. Code reusability and code sharing 
4. Backed by leading companies 2.1% of all websites
5. Asynchronous handling of requests
6. The availability of free tools

2. Express JS

Express JS is a lightweight framework for building web applications. It is built on top of Node.js and uses the CommonJS module system, which makes it easy to use in any JavaScript project. It also has lots of features, such as routing, validation, tagging, and more, that make it a good choice for building RESTful APIs.

In addition to its many useful features, Express JS has also been gaining popularity since its inception, by John McCrate as part of his course at Front End Masters (now Creative Coding).

Features of Express js

• Server-side development that is faster Features for developing web and mobile applications
• A layer built on top of Node js helps managing servers and routes.
• It enables developers to create APIs and web applications with ease
• Makes it easier to identifies bug areas

3. React Native

Known as an open-source, cross-platform app development framework, React Native was introduced by Facebook in 2018. It has been developed and maintained by the tech giant since its release. In addition, React Native simplifies iOS and Android app development, which plays a significant role in its popularity. There are a number of popular applications based on the React Native framework, such as Amazon Prime, Tesla, Skype, Airbnb, and so on.

Features of React Native include:

• Compatibility with third-party plugins
• Reusable components
• Superior performance
• It supports both iOS and Android.

4. Flutter

Flutter is an open-source framework developed by Google for creating cross-platform applications using one codebase. With its innovative design strategy for designing applications that have a native-like appearance and feel, this SDK is an excellent tool for building cross-platform applications. It is often the best choice for mobile app developers to create an engaging application with a highly reliable mobile user interface quickly.

The Flutter framework offers widgets, a rendering engine, testing, and a number of other tools to let programmers create and develop visually appealing mobile apps. Flutter technology is used by reputable companies, such as Alibaba, Google, and Abby Road Studios.

Features of the Flutter framework:

• powerful widget support
• Streamlining the development process
• highly reliable mobile user interface
• in-built material design
• Rich motion APIs
• high-performance app similar to native

5. Laravel

Laravel is definitely one of the most popular PHP frameworks to use and is ideal for all types of applications, especially custom requirements such as portal mobile apps, social media apps, It offers predefined templates that enable a quick and time-saving mobile app development process. For mobile developers, it creates a simpler backend development process, which makes it easy to meet the feature requirements of the user.

Though Laravel isn’t the only PHP framework, if you have already used it, you might use other popular PHP frameworks like CodeIgniter, CakePHP, or Zend Frameworks.

It includes the following features:

• Simpler backend development
• OPen-source framework 
• Quick and easy to market
• Enhanced security 
• Community support 

6. .NET MAUI (formerly known as Xamarin)

Xamarin has been a leading open-source, cross-platform application platform for the development of high-performance mobile apps for iOS, Android, and Windows since its introduction in 2011. The platform was deprecated in November 2021. It was eventually replaced by.NET MAUI (.NET Multi-Platform App UI), which is used by businesses across industries to create scalable and performant cross-platform Android and iOS apps.

“As per the survey, more than 15,000 organizations and 1.4 million programmers were using Xamarin.” The framework’s apps have an average market share of 1.88%, with business-related apps having the highest market share at 6.54%. 

The stats only highlight the popularity of Xamarin; developers can try out the new.NET MAUI to stay updated with its new versions.

7. Loopback

Loopback is a Node.js framework for creating APIs. It has an ORM, a CLI, and a REST API generator that generates all of the code you need to create your app’s APIs.

Loopback was originally created by the team behind Express and can be used with any database, so it’s easy to integrate into your existing projects if you have one (like MySQL). The core of Loopback is built on Express, but it includes more than just this framework; it also includes other useful modules such as form validation and authentication integration, making Loopback incredibly flexible when it comes to building apps in addition to APIs!

• Makes it easy to handle data in a persistence system
• Designed to create APIs and connecting them with backend data sources
• TCP loopback optimization to a low-latency loopback path for performance-critical applications
• Availability of offline data access and synchronization

8. Django

Developed in Python, Django is a free, open-source framework based on a model-view-template architecture. Django is designed by experienced developers to develop better web apps more quickly and with fewer lines of code. As well as taking away much of the hassle of web development, so you can focus on writing your app rather than reinventing the wheel. 

It is maintained by the Django Software Foundation (DSF), an independent organisation established to advance the Django software and its community. 

Django offers features such as:

• Exceptionally scalable 
• Designed to drive faster, clean and pragmatic development cycles
• Advance the state of the art in Web development.
• Protect the intellectual property and the framework’s long-term viability.

9. Ruby on Rails

A model-view-controller framework, Ruby on Rails is a Ruby-based open-source framework for developing web applications. This means that it separates your application into three main parts: models (representing data), views (displaying that data), and controllers (controlling the flow of your application).

Rails has become extremely popular because of its ease of use and flexibility. It allows developers to quickly build complex applications with minimal overhead, making them ideal when you need something fast but still want something robust enough to handle larger loads or more complex needs.

Features of Ruby on Rails include:

• Allow easy changes in codes for 
• Extremely scure server side web application 
• Database-backed web applications according to MVC pattern 
• Clean and easy to learn syntax for developers
• More organized and Object oriented 

10. Spring Boot

Spring Boot is a microservices framework that takes care of most of the boilerplate work for you. It’s designed to help you build fast, production-ready applications using only the features you need and none of the ones you don’t.

Spring Boot provides an opinionated set of features out of the box:

• a Maven repository with many pre-packaged dependencies, including spring-boot-starter, springfox, and orocrudus (more on these later).
• a simple configuration file that defines all your application’s dependencies, startup classes, and service definitions in one place.

This makes it easy for developers who already know how to use a tool like Gradle or Maven but haven’t had much experience with Java yet, because they’re not required to learn anything new!

Conclusion

Choosing the right mobile app backend framework isn’t always easy, so we’ve put together this handy guide on what makes for great software development tools for developers working on your next project!

This post describes the top mobile app backend development frameworks that help you build apps with amazing features and functionalities. However, it’s important to realise that there are many good choices for building a mobile app backend. You can use one of the frameworks listed above, or you can create your own custom one. If you’re new to developing apps, this article will help you decide which framework is best for your project’s needs.

The post Top 10 Mobile App Backend Frameworks for 2023: NodeJS, ExpressJS, React Native, Flutter, and More appeared first on Talent500 blog.

It is basically a reusable solution to a commonly occurring problem in software architecture within a given context. It addresses a variety of issues in the software engineering field. Developers generally use different patterns and tools that help them with the development and testing for various websites and applications. Also, we need something that allows faster reaction to design changes, which MVVM actually does.  MVVM is a software design pattern, separating an application to three main logical components.

Note: Link between Model and View Model is Manipulating Data and between ViewModel and View is 2-way Data Binding.  

View tells the View Model that the user has performed some action and based on that, View Model tells the View how it should update itself.

Example : User pulled the table view and pull to refresh was implemented.

So, the view will now tell the View Model that the user has pulled the table view and hence View Model knows that the service call has to be made, and now View Model will interact with the Network Layer. Network Layer will make the service call, models will be updated with new data.  When the Model will be updated, View Model will let the View know that data is available, update yourself.

DESCRIPTION OF THE MODEL :  

MODEL: ( Reusable Code – DATA ) Business Objects that encapsulate data and behavior of  application domain, Simply hold the data.  

VIEW: ( Platform Specific Code – USER INTERFACE ) What the user sees, The Formatted data.  VIEW-MODEL: ( Reusable Code – LOGIC ) Link between Model and View OR It Retrieves data  from Model and exposes it to the View. This is the model specifically designed for the View.  

FEATURES:  

1. Life Cycle state of Application will be maintained.  
2. Application will be in the same position as where the user left it.  
3. UI Components are kept away from Business Logic.  
4. Business Logic is kept away from Database operations.  
5. Easy to understand and read. 

BASIC EXAMPLE: We want to display Name in Pink Color (not written in proper format,  proper length) or Display Pink Color if Age of a person is > 20 years, Display Red Color if Age of a person is < 20 years, Then the Logic of Red and Pink Color would be present in  ViewModel.  

DIFFERENCES BETWEEN MVVM AND MVC: 

MVVM:  

1. The Model is somewhat similar to MVC but here we have ViewModels which are passed to  the view and all the logic is in the ViewModel and hence no controller is there. Example:  Knockout.js  
2. MVVM is relatively a new Model.
3. We are on the client side so we can hold on to objects and do a lot more logic in a non disconnected state  
4. Debugging process will be complicated when we have complex data bindings.
5. MVVM would be easier for separate unit testing and code is event-driven.

MVC:  

1. In this pattern, we have models which are basic objects with no code and just properties,  View’s contribute to presentation items (HTML, WinForms, etc) and Controllers focus on the  logic part. Examples: ASP.NET MVC, Angular  
2. MVC is an old Model.  
3. MVC is typically used when things are transactional and disconnected as is the case with  server side web. In ASP MVC we send the view through the wire and then the transaction with the  client is over.  
4. MVC is a bit difficult to read, change, unit test and to reuse as well.
5. Model can be separately tested from the user.

ADVANTAGES: 

1. Maintainability – Can remain agile and keep releasing successive versions quickly.  2. Extensibility – Have the ability to replace or add new pieces of code.  
2. Testability – Easier to write unit tests against a core logic.  
3. Transparent Communication – The view model provides a transparent interface to the view  controller, which it uses to populate the view layer and interact with the model layer, which  results in a transparent communication between the layers of your application.  

DISADVANTAGES: 

1. Some people think that for simple UIs, MVVM can be overkill.  
2. In bigger cases, it can be hard to design the ViewModel.  
3. Debugging would be a bit difficult when we have complex data bindings.

SUMMARY: From Server, Get Data(available in Model Objects), View Model reads Model  Objects, and then facilitates easy presentation of data on the view.  

We hope you got the idea of what MVVM is and can expect the similar things in your following interviews and daily coding. If you are looking for challenging opportunities at some of the fastest-growing global companies, join Talent500. Sign up here.

The post MVVM (MODEL VIEW VIEW-MODEL) appeared first on Talent500 blog.

Many Kotlin Android developers are in love with this new way of designing UI. JetPack Compose made dealing with recycler views, navigation, and animations so easy and straightforward. 

In this article, we will be discussing the most important topic which is State Hoisting in Compose. First, let’s take a look at what is a State in JetPack Compose, and then I’ll take you through different concepts of State Hoisting. Let’s go!

What is a State in JetPack Compose?

An app’s state is any value that can change during the execution of your app. App’s state determines what is displayed in the UI. 

A few examples of state in android apps are –

1. The most recent messages received in WhatsApp OR the most recent emails received in Gmail.
2. Scrolling YouTube videos, Instagram reels, Twitter tweets, etc.
3. Liking friend’s posts by pressing that Like button on Facebook.

Define State in Compose

State<T>

A type that holds a read-only value: It notifies the composition when the value changes.

MutableState<T>

It’s an extension function of the State. It allows us to update the value. When the value property is written to and changed, a recomposition of any subscribed compose scope will be scheduled. 

If value is written to with the same value, no recompositions will be scheduled.

Consider the following composable function — 

@SuppressLint(“UnrememberedMutableState”)
@Composable
fun Counter(modifier: Modifier = Modifier) {
    Column(modifier = modifier.padding(16.dp)) {
        val count: MutableState<Int> = mutableStateOf(0)
        Text(
            text = “You’ve had ${count.value} glasses today.”,
            modifier = modifier.padding(10.dp)
        )
        Button(onClick = { count.value++ }, modifier = Modifier.padding(top = 8.dp)) {
            Text(text = “Add One”)
        }
    }
}

Whenever we press the button and increase the count, the composable function recomposes and the UI should show the updated value but nothing happens. Why is that? 

The problem is that the variable is reinitialized to 0 when the function re-executes. 

This is where Remember API comes into the picture. You can use remember inline composable function like this — 

@Composable
fun Counter(modifier: Modifier = Modifier) {
    Column(modifier = modifier.padding(16.dp)) {
        val count: MutableState<Int> = remember { mutableStateOf(0) }
        Text(
            text = “You’ve had ${count.value} glasses today.”,
            modifier = modifier.padding(10.dp)
        )
        Button(onClick = { count.value++ }, modifier = Modifier.padding(top = 8.dp)) {
            Text(text = “Add One”)
        }
    }
}

Now the count value is stored in the composition and this value is being tracked across recompositions. 

Go to the app and press the button, and you can see that the state value is changing. The state mechanism is actually working!

So usually, remember and mutableStateOf are used together to manage states across the app at runtime.

There are a few ways to deal with State API to define states in compose.

1. Accessing the value property of a state object every time is the one way.

val count = remember { mutableStateOf(0) }
Text(
    text = “You’ve had ${count.value} glasses today.”,
    modifier = modifier.padding(10.dp)
)

2. Another way that is more convenient than the first one is with by keyword which uses Kotlin’s delegated properties. State object should be now an var instead of an val if you are using by keyword.

var count by remember { mutableStateOf(0) }
Text(
    text = “You’ve had $count glasses today.”,
    modifier = modifier.padding(10.dp)
)

What is State Hoisting?

State Hoisting is a pattern of moving state to a composable’s caller. Compose uses the state hoisting pattern to make composable stateless.

You can use the state object if you want to update the data at runtime in UI.

The general pattern for state hoisting in Jetpack Compose is to replace the state variable with two parameters:

1. value: T — the current value to display
2. onEventCallback: (T) -> Unit — an event that requests the value to change, where T is the proposed new value.  

Why is State Hoisting important?

State Hoisting has some important properties –

1. Single source of truth: It helps to avoid bugs while dealing with states in compose. It is being ensured that there is a single source of truth by moving the state out of composable instead of duplicating it every time the state needs to be changed.
2. Shareable: Hoisted state can be used with multiple composables. 
3. Encapsulated: Only stateful composable that hold the state will be able to modify their state.
4. Decoupled: The state of a stateless composable function can be stored anywhere. For example, the state value can be stored inside ViewModel.
5. Interceptable: Callers to stateless composable have the right to decide to ignore or modify events before changing the state.

Stateless VS Stateful Composable

Stateful Composable:

A composable that contains an internal state is a Stateful composable. 

Consider the following code — 

@Composable
fun StatefulCounter(
    modifier: Modifier = Modifier
) {
    Column(modifier = modifier.padding(16.dp)) {

        var counter by remember {
            mutableStateOf(0)
        }

        if (counter > 0) {
            Text(
                text = “You’ve had $counter glasses today.”,
                modifier = modifier.padding(10.dp)
            )
        }

        Button(
            enabled = counter < 10,
            onClick = { counter++ },
            modifier = modifier.padding(10.dp)
        ) {
            Text(text = “Add One”)
        }

    }
}

StatefulCounter is an example of stateful composable because it holds the count state value.

These composables tend to be less reusable and harder to test.

Stateless Composable:

Composables that don’t hold any state are called Stateless composables. 

An easier way to create stateless composable is by using state hoisting. 

Consider the following code for better understanding — 

@Composable
fun StatefulCounter(modifier: Modifier = Modifier) {

    var count by rememberSaveable {
        mutableStateOf(0)
    }

    StatelessCounter(count, {count++}, modifier = modifier)
}

@Composable
fun StatelessCounter(
    count: Int,
    onIncrement: () -> Unit,
    modifier: Modifier = Modifier
) {
    Column(modifier = modifier.padding(16.dp)) {

        if (count > 0) {
            Text(
                text = “You’ve had $count glasses today.”,
                modifier = modifier.padding(10.dp)
            )
        }

        Button(
            enabled = count < 10,
            onClick = onIncrement,
            modifier = modifier.padding(10.dp)
        ) {
            Text(text = “Add One”)
        }
    }
}

StatelessCounter composable is a stateless composable because it does not hold any state. Instead, it will hoist the state provided by StatefulCounter the caller composable and hoist it. This pattern is called State Hoisting.

Stateless composables are more reusable and easier to test as well.

Remember VS Remember Savable

Remember

remember keyword can be used to store both mutable and immutable objects. If the change happens in a state’s value, it will recompose the UI widgets and show the updated UI on the screen. 

var count by remember { mutableStateOf(0) }

What will happen if you rotate the device once the state is updated? You will see that composable is initialized again with the initial state value.

The same happens if you change the language, switch between dark and light modes, or any other configuration change that makes Android recreate the running Activity.

remember helps you retain state across recompositions, but it’s not helpful in retaining state across such configuration changes.

Remember Savable

Use rememberSavable to avoid the drawback of using remember. It will help you retain state across configuration changes where the activity and process are recreated. 

It means that you can restore your UI even after an activity or process is recreated. 

var count by rememberSaveable { mutableStateOf(0) }

Now try to rotate your device again and see if the state is restored or not. You will see that the state is actually retained in the UI.

Conclusion

Amazing! Now you have an idea about state management in JetPack Compose. By the end of this article, you’ve hopefully learnt about state hoisting and some important points to remember while dealing with states in composition. 

The post State Hoisting in JetPack Compose appeared first on Talent500 blog.

I’ll give you an example of why we may need Android flavors. Suppose you want to publish your app in two sections. The first one is “free” and the second one is “paid”.

The free app will contain only 3 features out of 6, and the paid app will contain all the features available for users. Aside from this, all other functionalities are the same for the two apps.

What should we do to achieve this?

Your initial thought would be to maintain two different codebases or projects for each app. But… but… will this be fine to maintain two different heavy-sized projects? Of course not!

Doing changes in both projects manually and repeatedly will be error-prone. This will be a tedious task to do as there are chances of misconfiguration.

So here, Product Flavors come into the picture. Using flavors, you can build multiple apps by just maintaining a single codebase. 

Different Flavors

What are Product Flavors?

Product flavor is a very powerful feature available in the Android Gradle Plugin that allows us to manage different variants of an application.

Product flavors are useful when you want to create different versions of your app while using a single codebase.

Now, I will give an explanation of some keywords for better clarity.

Build Variants

Build variants are the result of Gradle using a specific set of rules to combine settings, code, and resources configured in your build types and product flavors.

Build variants are formed using build types and product flavors.

Build Types

A build type determines how an app is packaged. It refers to build and packaging settings like signing configuration for a project.

By default, the Android plug-in for Gradle supports two different types of builds: “debug” and “release”.

buildTypes {
    release {
        debuggable false
        minifyEnabled false
        proguardFiles getDefaultProguardFile(‘proguard-android-optimize.txt’), ‘proguard-rules.pro’
    }    debug {
        debuggable true
    }
}

Creating Product Flavors

To create product flavors, go to build.gradle file and create your flavors inside android block like this –

flavorDimensions += “version”
productFlavors {
    create(“free”) {
        dimension = “version”
        applicationIdSuffix = “.free”
        versionNameSuffix = “-free”
    }

    create(“paid”) {
        dimension = “version”
        applicationIdSuffix = “.paid”
        versionNameSuffix = “-paid”
    }
}

All flavors must belong to a named flavor dimension, which is a group of product flavors. You must assign all flavors to a flavor dimension; otherwise, you will get the build error.

Error: All flavors must now belong to a named flavor dimension.
The flavor ‘flavor_name’ is not assigned to a flavor dimension.

Now click on sync now or run the Gradle build. Once the Gradle build is done, you can see your created product flavors inside the Build Variants tab.

Now each flavor can perform a different set of tasks such as – Unique app display name, android package name, app icon and colour themes.

You can create as many product flavors as you want in your app. Then each flavor can have unique properties and different code files.

This is how you can define flavors –

flavorDimensions “version”
productFlavors {

    create(“Wave-2”) {
        dimension “version”
        versionName “$defaultConfig.versionName” + “.wave-2”

        // diff package name
        applicationId “com.app.adv”

        resValue “string”, “app_name”, “@string/wave2_app_name”
        resValue “color”, “colorPrimary”, “@color/colorPrimaryWave2”
        resValue “color”, “colorPrimaryDark”, “@color/colorPrimaryDarkWave2”
        resValue “color”, “colorAccent”, “@color/colorAccentWave2”
        resValue “color”, “colorPrimary_op20”, “@color/colorPrimary_op20Wave2”

        // diff app icon
        manifestPlaceholders = [
                appIcon: “@mipmap/ic_launcher_wave_2”,
                appIconRound: “@mipmap/ic_launcher_round_wave_2”
        ]
    }

    create(“QA”) {
        dimension “version”
        versionName “$defaultConfig.versionName” + “.qa”

        applicationId “com.app.dev”

        resValue “string”, “app_name”, “@string/qa_app_name”
        resValue “color”, “colorPrimary”, “@color/colorPrimaryQA”
        resValue “color”, “colorPrimaryDark”, “@color/colorPrimaryDarkQA”
        resValue “color”, “colorAccent”, “@color/colorAccentQA”
        resValue “color”, “colorPrimary_op20”, “@color/colorPrimary_op20QA”

        manifestPlaceholders = [
                appIcon     : “@mipmap/ic_launcher_qa”,
                appIconRound: “@mipmap/ic_launcher_qa_round”
        ]

    }
}

Want to add different code files to each product flavor?

Yes, you can do this. First of all, you need to define a structure for each product flavor.

1. Head down to the Project structure of your app, and right-click on the src folder.
2. Choose New -> Folder -> Java Folder
3. Choose the target productFlavor name.

Conclusion

Use this awesome android feature to create multiple apps without worrying about different codebases. It helps to keep the code tidy. I got to learn about product flavors through my task. And I was able to gain some useful insights from my learning. If you want to learn more about Product Flavors, go through Google’s official document.

https://developer.android.com/studio/build/build-variants

The post Product Flavors in Android — Different Builds with the Same Codebase appeared first on Talent500 blog.