1. Unit-1 Android Basics of Android.pptx

Android Basics

1. ANDROID MOBILE APPLICATION DEVELOPMENT

2. Android Continues to Rule the OS Market In 2024 and Android continues to be the most popular operating software with a 70% market share. This means, that out of the 8.08 billion global population, more than  3.9 billion own Android phones.   While all this data might not sound shocking to you, the point we want to make is that – now more than ever,  mobile app development companies  need to pay close attention to what’s trending with Android apps. Look at the chart below that shows how Android users have grown over the last decade.  It also shows how it’s expected to touch 4.2 billion users by 2025.

3. Machine Learning and Artificial Intelligence One of the most significant Android application development trends is incorporating  artificial intelligence and machine learning . These technologies are being used to create more personalized and intuitive experiences for users and improve the performance and functionality of applications. For example, many applications now use machine learning to analyze user data and make predictions, while others are incorporating chatbots to provide more efficient customer service. Video Editor and Maker Video editing and making is a popular trend in Android app development. Many video editing and making apps on the Google Play Store allow users to create, edit, and share videos on their Android devices. These apps typically include features such as video trimming, merging, adding filters and effects, and more. Additionally, many apps allow easy sharing on social media platforms such as YouTube, Instagram, and TikTok.

4. DeepFake Apps Deepfake technology, which uses machine learning to manipulate video and audio content, has become a trending topic in recent years. The technology has advanced significantly, making it possible to create highly realistic deep fake videos with just a few clicks. As a result, deepfake apps have begun to appear on the Google Play Store, allowing users to create and share their deep-fake videos and photos on their Android devices. HealthCare Apps Healthcare apps have become a popular trend in Android app development. These apps can assist users in tracking and managing their health, from monitoring vital signs to reminding them to take medication. These apps have a wide range of features, such as: Tracking and monitoring fitness and physical activity Tracking and logging food and water intake Tracking sleep patterns Tracking mental and emotional well-being Providing reminders for taking medication and scheduling doctor's appointments Connecting with healthcare providers for remote consultations and monitoring.

5. The  healthcare app development  is driven by the increasing adoption of smartphones and the internet and the need for more convenient and accessible healthcare services. With the rise of telemedicine, the trend is expected to continue growing as more people turn to their devices for healthcare needs. It's worth noting that while healthcare apps can be a valuable tool in managing one's health, they are not meant to replace professional medical advice. It is essential to consult with a healthcare provider before using a healthcare app and to use it with professional medical guidance.

6. Productivity Apps & Tools There has been a recent trend toward developing productivity apps and tools for Android devices. These apps and tools are designed to help users manage their time more effectively and efficiently. They can include task management, attendance management, calendar integration, and note-taking capabilities. Some popular productivity apps for Android include Todoist , Evernote, and Google Keep. Additionally, there has been an increase in the use of virtual assistants, such as Google Assistant, to help users manage their tasks and schedule. 5G Technology The emergence of  5G technology  has led to new opportunities for Android app development. 5G networks offer faster speeds and lower latency than previous generations of cellular networks, allowing more data to be transmitted in a shorter amount of time. This opens up new possibilities for developers to create apps that can take advantage of the increased bandwidth and responsiveness of 5G networks.

7. Blockchain Technology Blockchain technology is a decentralized and distributed digital ledger used to record transactions across a network of computers. The technology powers cryptocurrencies like Bitcoin and Ethereum but has many other potential uses, such as supply chain management, voting systems, etc. Android app development is one area where blockchain technology is increasingly used as developers look to create decentralized apps ( dApps ) that can take advantage of the security and immutability of blockchain technology. Some popular use cases for blockchain in Android app development include creating decentralized marketplaces, digital wallets, and lending platforms.

8. Augmented and Virtual Reality Augmented and virtual reality  are also expected to increase in 2023. These technologies create more immersive and engaging user experiences, allowing them to explore virtual worlds or view products in 3D. This is especially relevant in the gaming, education, and entertainment industries. Foldable Devices Foldable devices, such as smartphones and tablets with flexible displays, are a relatively new trend in Android technology. As more and more of these devices hit the market, developers are beginning to take notice and adapt their apps to take advantage of the unique capabilities of these devices.

9. Instant Apps Instant Apps are a relatively new Android app development trend that allows users to run apps without installing them on their devices. Instead, users can access the app through a web link, allowing them to try it before committing to a complete installation. Faster Access to Apps Instant apps allow users to access apps quickly without downloading and installing them. This can be useful for apps that are only needed occasionally, such as shopping apps, or for users who need more storage space on their devices. Better Discovery Instant apps make it easier for users to discover new apps, as they can be accessed through web links or search engines, increasing an app's visibility and the chances of being downloaded. Increased Conversion Rates By allowing users to try out an app before committing to a full installation, instant apps can increase the likelihood that a user will convert to a full installation. It is beneficial for app developers, as it can lead to increased downloads and revenue.

10. IoT-Enabled App IoT (Internet of Things) enabled apps are a growing trend in Android app development, as they allow for integrating smart devices and connected appliances into android applications. These apps can control and monitor many devices, from smart thermostats to security cameras, and provide users with a more connected and automated home experience. Smart Home Control IoT-enabled apps allow users to control and monitor a wide range of smart devices and connected appliances from their devices, such as lights, thermostats, and security cameras. Automation and Personalization IoT-enabled apps are used to automate specific tasks and personalize the user experience. For example, users can adjust their thermostats to their preferred temperature when they arrive home or set their lights to turn off automatically when they leave.

11. Android vs iOS User Growth The iOS vs Android supremacy debate has been going on for quite many years now without a clear winner. iOS dominates in terms of better updates and support, brand loyalty, eco-system lock-ins, and security. However, the volume game belongs to Android.  It’s not just because Android phones can cater to a more diverse market with a wider affordability range. Its open ecosystem, customization, and flexibility options also make them a great choice for app developers and businesses. Let’s not forget how Android phones are popular in the emerging markets that are just beginning to adopt smartphones. Add seamless integration with Google services to that, and Android hits the jackpot of value-added convenience to a very large user base. These users also need access to Gmail, Google Drive, and Google Maps on a daily basis.

12. Introduction: Mobile Applications Android is a mobile operating system developed by Google and is used by a variety of devices such as smart phones, tablets, smart watches, and TVs.

13. These apps are built to perform a wide range of tasks and offer various functionalities that cater to the needs of users. Mobile applications have become an integral part of modern life, offering convenience, entertainment, productivity, and access to information on-the-go.

14. There are two main types of mobile applications based on the platform they are developed for: 1. Native Mobile Applications: These apps are specifically developed for a particular mobile operating system (OS) like Android or iOS , utilizing the programming languages and development tools native to that platform. Native apps can take full advantage of the device's hardware and features, providing optimal performance and user experience. However, separate development is required for each platform, which can increase development time and cost.

15. 2. Cross-Platform Mobile Applications: Cross-platform apps are designed to work on multiple mobile platforms, allowing developers to write code once and deploy it across different operating systems. This is achieved using frameworks like React Native, Flutter, or Xamarin , which enable developers to create a single codebase that can be used on both Android and iOS devices . Cross-platform development reduces development time and costs but may have some limitations in accessing certain device-specific features.

16. Mobile applications cover a vast array of categories, including but not limited to: Social networking apps (e.g., Facebook , Twitter, Instagram ) Productivity and utility apps (e.g., Microsoft Office, Ever note, Google Drive) Entertainment apps (e.g., YouTube, Netflix, Spotify ) Gaming apps (e.g., Candy Crush, PUBG Mobile, Pokémon GO) E-commerce apps (e.g., Amazon, eBay, Alibaba ) News and media apps (e.g., CNN, BBC News, The New York Times) Health and fitness apps (e.g., Fitbit , MyFitnessPal , Headspace) Travel and navigation apps (e.g., Google Maps, Uber , Airbnb )

17. Version Code name API Level Code name Version numbers API level Release date No codename 1.0 1 September 23, 2008 No codename 1.1 2 February 9, 2009 Cupcake 1.5 3 April 27, 2009 Donut 1.6 4 September 15, 2009 Eclair 2.0 - 2.1 5 - 7 October 26, 2009 Froyo 2.2 - 2.2.3 8 May 20, 2010 Gingerbread 2.3 - 2.3.7 9 - 10 December 6, 2010 Honeycomb 3.0 - 3.2.6 11 - 13 February 22, 2011 Ice Cream Sandwich 4.0 - 4.0.4 14 - 15 October 18, 2011 Jelly Bean 4.1 - 4.3.1 16 - 18 July 9, 2012 KitKat 4.4 - 4.4.4 19 - 20 October 31, 2013 Lollipop 5.0 - 5.1.1 21- 22 November 12, 2014 Marshmallow 6.0 - 6.0.1 23 October 5, 2015 Nougat 7.0 24 August 22, 2016 Nougat 7.1.0 - 7.1.2 25 October 4, 2016 Oreo 8.0 26 August 21, 2017 Oreo 8.1 27 December 5, 2017 Pie 9.0 28 August 6, 2018 Android 10 10.0 29 September 3, 2019 Android 11 11 30 September 8, 2020

18. Template for Phone and Tablet Activities

19. Empty Activity: This is the simplest default activity. It creates a blank screen with a basic layout file and a corresponding Java/ Kotlin class. You can start building your app from scratch with this option. Basic Activity: The Basic Activity template includes a pre-designed layout with an action bar (toolbar) at the top. It also comes with some basic functionalities like a floating action button (FAB) and a navigation drawer. Bottom Navigation Activity: This template provides an app with a bottom navigation bar, allowing users to navigate between different app sections or tabs. Tabbed Activity: This template includes a tab layout that allows you to organize your app's content into tabs, making it easy for users to switch between different sections.

20. Master/Detail Flow: This template is suitable for apps that need to display a list of items and their details. It creates a master list view and a detail view for each item. Full screen Activity: The Full screen Activity template creates an activity that displays content in full screen mode, hiding the system UI elements (status bar and navigation bar) until the user interacts with the screen. Login Activity: This template provides a basic login screen with fields for username and password. It is a good starting point for apps that require user authentication. Maps Activity: If your app involves displaying maps and location-based services, this template sets up a map fragment and includes some basic map functionalities.

21. https://www.businessofapps.com/data/android-statistics/

22. Linux kernel It is the heart of android architecture that exists at the root of android architecture. Linux kernel is responsible for device drivers, power management, memory management, device management and resource access. Bottom layer of android operating system is Linux kernel. Android is built on top of Linux 2.6 Kernel and few architectural changes made by Google. Linux Kernel provides the basic system functionality such as process management, memory management and device management like camera, keypad, display etc. It also provides array of device drivers which makes interfacing the android with peripheral hardware easy.

23. Library Explanation SQLite This library is used to access data published by content providers and includes SQLite database management classes SSL This is used to provide internet security OpenGL OpenGL is  used to provide Java interface to the OpenGL/ES 3D graphics rendering API. Media framework It is used to provides different media codecs which allow the recording and playback of different media formats WebKit It is the browser engine used to display internet content or HTML content Web browser Based on the open-source WebKit layout engine, coupled with Chrome’s V8 JavaScript engine supporting HTML5 and CSS3. Libraries On the top of Linux Kernel another layer called libraries is present. It provides the different libraries useful for well functioning of android operating system. Libraries are java libraries build specific for android operating system. Some of important libraries are

24. It is the third component of the android architecture and placed in second layer from bottom. It provides most important part of android called Dalvik Virtual Machine. Dalvik Virtual Machine is similar to Java Virtual Machine (JVM) but only difference is that it is designed and optimized for Android. Dalvik Virtual machine uses core functions of Linux such as memory management and multi threading and enables each android app to run its own process. The Android runtime also provides a set of core libraries which enable Android application developers to write Android applications using standard Java programming language.

25. Platform libraries The Platform Libraries includes various C/C++ core libraries and Java based libraries such as Media, Graphics, Surface Manager, OpenGL etc. to provide a support for android development. Media  library provides support to play and record an audio and video formats. Surface manager  responsible for managing access to the display subsystem. SGL  and  OpenGL  both cross-language, cross-platform application program interface (API) are used for 2D and 3D computer graphics. SQLite  provides database support and  FreeType  provides font support. Web-Kit  This open source web browser engine provides all the functionality to display web content and to simplify page loading. SSL (Secure Sockets Layer)  is security technology to establish an encrypted link between a web server and a web browser.

26. SGL stands for "Scalable Graphics Library" and is the graphics subsystem used by Android. SGL is the low-level graphics library implemented in native code that handles rendering. The Secure Sockets Layer (SSL)—now technically known as Transport Layer Security (TLS)—is a common building block for encrypted communications between clients and servers.

27. Application framework It is fourth component in android operating system stack. Android applications  directly interacts with application framework. Application framework manages the basic functions of android device such as resource management, voice call management etc. Application Framework layer provides many higher-level services to applications in the form of Java classes. Application developers are allowed to make use of these services in their applications. The important blocks of application framework are:

28. AP Block Explanation Activity Manager Used to manage complete activity life cycle of applications Content Providers Used to manage the data sharing between two applications Telephony Manager Used to manages all voice calls Location Manager Used to manage the Locations obtained using GPS or cell tower Resource Manager Used to manage the different types of resources used in android app

29. Applications Android application is the fifth component of android OS and situated at the top layer. Applications are developed to be installed on this layer only. Examples of such applications are Contacts Books, Browser, Games, etc.

30. Android Resources Organizing & Accessing There are many more items which you use to build a good Android application. Apart from coding for the application, you take care of various other  resources  like static content that your code uses, such as bitmaps, colors, layout definitions, user interface strings, animation instructions, and more. These resources are always maintained separately in various sub-directories under  res/  directory of the project. This tutorial will explain you how you can organize your application resources, specify alternative resources and access them in your applications.

31. Sr.No. Directory & Resource Type 1 anim/ XML files that define property animations. They are saved in res/anim/ folder and accessed from the  R.anim  class. 2 color/ XML files that define a state list of colors. They are saved in res/color/ and accessed from the  R.color  class. 3 drawable/ Image files like .png, .jpg, .gif or XML files that are compiled into bitmaps, state lists, shapes, animation drawable. They are saved in res/drawable/ and accessed from the  R.drawable  class. 4 layout/ XML files that define a user interface layout. They are saved in res/layout/ and accessed from the  R.layout  class. 5 menu/ XML files that define application menus, such as an Options Menu, Context Menu, or Sub Menu. They are saved in res/menu/ and accessed from the  R.menu  class.

32. 6 raw/ Arbitrary files to save in their raw form. You need to call  Resources.openRawResource()  with the resource ID, which is  R.raw.filename  to open such raw files. 7 values/ XML files that contain simple values, such as strings, integers, and colors. For example, here are some filename conventions for resources you can create in this directory − arrays.xml for resource arrays, and accessed from the  R.array  class. integers.xml for resource integers, and accessed from the  R.integer  class. bools.xml for resource boolean , and accessed from the  R.bool  class. colors.xml for color values, and accessed from the  R.color  class. dimens.xml for dimension values, and accessed from the  R.dimen  class. strings.xml for string values, and accessed from the  R.string  class. styles.xml for styles, and accessed from the  R.style  class. 8 xml/ Arbitrary XML files that can be read at runtime by calling  Resources.getXML () . You can save various configuration files here which will be used at run time.

33. Alternative Resources Your application should provide alternative resources to support specific device configurations. For example, you should include alternative drawable resources ( i.e.images ) for different screen resolution and alternative string resources for different languages. At runtime, Android detects the current device configuration and loads the appropriate resources for your application.

34. Application Model In Android, an application model refers to the way in which applications are designed, developed, and deployed on the platform. The Android application model is based on the principles of modularity, security, and flexibility. The key components of the Android application model include: Activities : Activities are the building blocks of Android applications. They represent individual screens or user interfaces within an application. Services : Services are components that run in the background and perform long-running operations or provide functionality to other applications. Broadcast Receivers : Broadcast receivers are components that listen for system events or broadcasts and allow applications to respond to them. Content Providers : Content providers are components that allow applications to share data with other applications. Intents : Intents are messages that are sent between components within an application or between different applications.

35. The Android application model also includes a set of APIs and frameworks that developers can use to create rich, engaging applications. Some of these include: User Interface Framework : This framework provides developers with tools to create interactive user interfaces for their applications. Application Framework : This framework provides developers with access to system-level functionality and services, such as the camera, sensors, and location services. Storage Framework : This framework provides developers with tools to store and retrieve data from various types of storage, such as databases, files, and shared preferences.

36. Infrastructure and Managing Resources Infrastructure and resource management are essential aspects of building robust and efficient Android applications. Here are some key considerations for managing resources and infrastructure in Android: Memory Management : Android applications run on devices with limited memory and resources. It is essential to manage memory efficiently to ensure smooth performance and avoid application crashes. Android provides a garbage collector that automatically frees up memory by removing objects that are no longer in use. However, it is also essential to release resources such as files, database connections, and network connections when they are no longer required. Network Management : Android applications typically rely on network connections to communicate with servers and fetch data. To manage network connections effectively, it is important to use Android's network APIs, which include HTTP, HTTPS, and WebSocket protocols. It is also essential to handle errors and network connectivity issues gracefully, such as retrying failed requests and displaying appropriate error messages.

37. User Interface Management : Android provides a variety of UI components such as buttons, text fields, and lists. It is important to design the UI efficiently to ensure a smooth user experience. Some best practices for UI management include using the appropriate UI components, optimizing the layout of UI elements, and providing responsive feedback to user actions. Battery Management : Android devices rely on battery power, and it is important to manage power consumption efficiently to avoid draining the battery too quickly. Some best practices for battery management include minimizing network usage, avoiding CPU-intensive operations, and using Android's power-saving features such as Doze mode and App Standby mode.

38. Storage Management: Android applications may need to store data on the device, such as files, images, and user preferences. It is important to manage storage efficiently to avoid running out of space and causing performance issues. Some best practices for storage management include using Android's storage APIs, compressing files and images, and removing unused files and data regularly.

39. Frameworks and Tools

40. There are many frameworks and tools available for developing Android applications. Here are some popular ones: Android Studio : Android Studio is the official integrated development environment (IDE) for Android development. It includes features such as code editing, debugging, and performance profiling tools. Java : Java is the official programming language for Android development. Android Studio provides support for coding in Java. Kotlin : Kotlin is a modern programming language that is gaining popularity among Android developers due to its concise syntax and improved readability.

41. Gradle : Gradle is a build automation tool that is used to manage dependencies and build Android projects. Android Studio uses Gradle to build, test, and deploy Android apps. Android SDK : The Android Software Development Kit (SDK) provides tools and APIs for Android development. It includes a range of libraries and tools for developing Android apps. Retrofit : Retrofit is a REST client library for Android that simplifies the process of making network requests and handling responses. Glide : Glide is an image loading and caching library for Android that provides smooth scrolling and efficient memory usage.

42. Firebase : Firebase is a backend-as-a-service ( BaaS ) platform that provides a range of tools for building and managing Android apps. It includes features such as authentication, real-time database, and cloud messaging. Room : Room is a persistence library for Android that provides an abstraction layer over SQLite . It simplifies the process of working with databases in Android apps. ButterKnife : ButterKnife is a view binding library for Android that simplifies the process of binding views and setting listeners. It helps reduce boilerplate code in Android apps.

43. Mobile devices Profiles

44. In Android, a profile is a collection of settings and configurations that are specific to a particular user or scenario. Profiles allow users to customize their device to suit their needs and preferences, and to switch between different configurations depending on the situation. There are several types of profiles in Android, including: User profiles : User profiles allow multiple users to share a single device while maintaining their own personalized settings, preferences, and data. Each user has their own profile, which can be accessed by logging in with their own credentials. Work profiles : Work profiles allow users to separate their work and personal data on a single device. Work profiles are managed by an organization's IT department and provide a secure environment for work-related apps and data.

45. Device owner profiles : Device owner profiles are used by organizations to manage devices that are used exclusively for work purposes. Device owner profiles give organizations complete control over the device and its settings. Guest profiles : Guest profiles are temporary profiles that can be created for visitors or other temporary users of the device. Guest profiles provide a limited set of features and settings and do not save any user data.

46. Application Design

47. Designing an application for Android involves several important steps to ensure that the app is user-friendly, visually appealing, and functional. Here are some key steps in the application design process for Android: Define the purpose and scope of the application : Before starting the design process, it's important to have a clear understanding of the purpose and scope of the app. This includes identifying the target audience, the features and functions that the app will provide, and the overall user experience. Sketch out the app's layout and structure : Once you have a clear understanding of the purpose and scope of the app, you can begin to sketch out the layout and structure of the app. This involves creating wireframes or mockups that show the different screens and features of the app.

48. Choose a design theme and color scheme : Choosing a design theme and color scheme is an important step in creating a visually appealing app. This involves selecting a color palette and design elements that will help to convey the app's purpose and brand identity. Design the user interface : The user interface (UI) is the visual aspect of the app that users interact with. This includes the layout of the app's screens, the placement of buttons and other interactive elements, and the use of icons and other visual cues. Develop the app's functionality : Once the UI has been designed, the next step is to develop the app's functionality. This involves writing the code that will enable the app to perform its various functions, such as displaying content, processing user input, and communicating with other devices or services.

49. Test and refine the app : Testing is a critical step in the application design process. This involves testing the app on a variety of devices and platforms to ensure that it works correctly and meets the needs of the target audience. Refinement may be necessary to fix bugs, improve performance, and optimize the user experience. Launch and promote the app : Once the app has been tested and refined, it's time to launch it to the public. This involves submitting the app to the Google Play Store or other app marketplaces and promoting it through various marketing channels. Ongoing maintenance and updates may be necessary to ensure that the app continues to meet the needs of its users.

50. Memory Management

51. Memory management in Android is an important aspect of the operating system that helps to ensure optimal performance and stability of the device. Android is designed to manage memory efficiently and effectively through several key mechanisms. Memory Allocation : When an application is launched, the Android system allocates a fixed amount of memory to it. This memory is used by the application to store data and execute code. If the application requires more memory than is allocated, the system may terminate it. Garbage Collection : As applications run, they create objects in memory. Some of these objects are no longer needed and become garbage. The Android system periodically performs garbage collection to reclaim memory that is no longer in use.

52. Low Memory Management : If the device runs low on memory, the Android system will begin to aggressively reclaim memory from running applications. This can cause some applications to become unstable or even crash. Memory Leaks : Memory leaks occur when an application fails to release memory that is no longer needed. This can cause the device to run out of memory and become unstable. Android provides tools to help developers identify and fix memory leaks. Large Heap Support : Android supports large heap sizes for devices with more memory, allowing applications to allocate more memory and run more efficiently.

53. Caching and Pre fetching : Android uses caching and prefetching to improve performance and reduce memory usage. Caching allows frequently accessed data to be stored in memory for quick access, while prefetching loads data into memory before it is needed to reduce load times.

54. Design patterns for limited memory

55. Designing Android applications for limited memory requires careful consideration of how resources are allocated and managed. Here are some design patterns that can help you optimize memory usage in your Android app: Use the Flyweight pattern : This pattern is useful when you need to create a large number of objects that have similar properties. Rather than creating a new object for each instance, you can reuse objects by sharing them among instances. This can reduce memory usage and improve performance. Implement the Singleton pattern : This pattern ensures that only one instance of an object is created and used throughout the application. This can be useful for objects that are used frequently or that consume a lot of memory.

56. Use the Object Pool pattern : This pattern involves creating a pool of pre-allocated objects that can be reused as needed. This can be useful for objects that are expensive to create or that are used frequently. Implement the Lazy Initialization pattern : This pattern involves deferring the creation of an object until it is actually needed. This can be useful for objects that are expensive to create or that may not be needed in every execution path. Use the Builder pattern : This pattern allows you to create complex objects by breaking down the construction process into smaller steps. This can help you avoid creating unnecessary objects or data structures, which can help reduce memory usage.

57. Implement the Observer pattern : This pattern allows you to notify interested objects of changes to another object. This can help you avoid creating unnecessary objects or data structures to track changes. Use the Iterator pattern : This pattern allows you to iterate over a collection of objects without having to create a separate data structure to hold the objects. This can help reduce memory usage by avoiding the need to create a large data structure to hold all the objects.

58. Activity Life Cycle <? xml version ="1.0" encoding ="utf-8" ?> < androidx.constraintlayout.widget.ConstraintLayout xmlns: android ="http://schemas.android.com/apk/res/android" xmlns: app ="http://schemas.android.com/apk/res-auto" xmlns: tools ="http://schemas.android.com/tools" android :layout_width =" match_parent " android :layout_height =" match_parent " android :background ="@color/ whatsAppColor " tools :context =". MainActivity " >

59. < TextView android :id ="@+id/ tvFirstActivity " android :layout_width =" wrap_content " android :layout_height =" wrap_content " android :text ="MCA 1 Sem " android :textColor ="@color/Red" android :textSize ="48sp" app :layout_constraintBottom_toBottomOf ="parent" app :layout_constraintEnd_toEndOf ="parent" app :layout_constraintStart_toStartOf ="parent" app :layout_constraintTop_toTopOf ="parent" /> </ androidx.constraintlayout.widget.ConstraintLayout >

60. < activity android :name =". SecondAcivity " android :exported ="false" /> < activity android :name =". MainActivity " android :exported ="true" > < intent-filter > < action android :name =" android.intent.action.MAIN " /> < category android :name =" android.intent.category.LAUNCHER " /> </ intent-filter > </ activity > </ application >

61. Java file package com.dcsa.activitylifecycle ; import androidx.appcompat.app.AppCompatActivity ; import android.content.Intent ; import android.os.Bundle ; import android.view.View ; import android.widget.TextView ; import android.widget.Toast ; public class MainActivity extends AppCompatActivity { @Override protected void onCreate ( Bundle savedInstanceState ) { super .onCreate ( savedInstanceState ); setContentView ( R . layout . activity_main ); Toast . makeText ( this , " onCreat " , Toast . LENGTH_LONG ).show(); TextView textView = findViewById ( R . id . tvFirstActivity ); textView .setOnClickListener ( new View . OnClickListener () { @Override public void onClick ( View view ) { Intent intent = new Intent( MainActivity . this , SecondAcivity . class ); startActivity ( intent ); } });

62. } @Override protected void onStart () { super .onStart (); Toast . makeText ( getApplicationContext (), " onStart" , Toast . LENGTH_LONG ).show(); } @Override protected void onResume () { super .onResume (); Toast . makeText ( getApplicationContext (), " onResume" , Toast . LENGTH_LONG ).show(); } @Override protected void onPause () { super .onPause (); Toast . makeText ( getApplicationContext (), " onPause" , Toast . LENGTH_LONG ).show(); } @Override protected void onStop () { super .onStop (); Toast . makeText ( getApplicationContext (), " onStop" , Toast . LENGTH_LONG ).show(); }

63. @Override protected void onRestart () { super .onRestart (); Toast . makeText ( getApplicationContext (), " onRestart" , Toast . LENGTH_LONG ).show(); } @Override protected void onDestroy () { super .onDestroy (); Toast . makeText ( getApplicationContext (), " onDestroy" , Toast . LENGTH_LONG ).show(); } }

64. Design patterns for limited memory

65. Designing Android applications for limited memory requires careful consideration of how resources are allocated and managed. Here are some design patterns that can help you optimize memory usage in your Android app: Use the Flyweight pattern : This pattern is useful when you need to create a large number of objects that have similar properties. Rather than creating a new object for each instance, you can reuse objects by sharing them among instances. This can reduce memory usage and improve performance. Implement the Singleton pattern : This pattern ensures that only one instance of an object is created and used throughout the application. This can be useful for objects that are used frequently or that consume a lot of memory.

66. Use the Object Pool pattern : This pattern involves creating a pool of pre-allocated objects that can be reused as needed. This can be useful for objects that are expensive to create or that are used frequently. Implement the Lazy Initialization pattern : This pattern involves deferring the creation of an object until it is actually needed. This can be useful for objects that are expensive to create or that may not be needed in every execution path. Use the Builder pattern : This pattern allows you to create complex objects by breaking down the construction process into smaller steps. This can help you avoid creating unnecessary objects or data structures, which can help reduce memory usage.

67. Implement the Observer pattern : This pattern allows you to notify interested objects of changes to another object. This can help you avoid creating unnecessary objects or data structures to track changes. Use the Iterator pattern : This pattern allows you to iterate over a collection of objects without having to create a separate data structure to hold the objects. This can help reduce memory usage by avoiding the need to create a large data structure to hold all the objects.

68. Work flow for Application Development

69. The workflow for application development in Android generally involves the following steps: Idea Generation : The first step is to generate an idea for the application. This can be done by researching the market, identifying user needs, and analyzing existing applications. Planning : Once the idea is generated, the next step is to plan the application. This involves identifying the features, functionalities, and user interface of the application. It also involves creating wireframes and mockups to visualize the application. Design : The design phase involves creating the visual design of the application. This includes creating a style guide, selecting colors, fonts, and images, and creating the user interface design.

70. Development : The development phase involves writing the code for the application. This includes creating the front-end and back-end of the application, integrating APIs, and testing the code. Testing : Once the application is developed, it needs to be tested thoroughly to ensure that it is free from bugs and errors. Testing can be done manually or through automated testing tools. Deployment : After the application is tested, it is ready to be deployed to the Google Play Store. This involves creating an account on the Google Play Store, uploading the application, and submitting it for review. Maintenance : Once the application is deployed, it needs to be maintained and updated regularly. This involves fixing bugs, adding new features, and improving the user experience.

71. Techniques for composing Applications

72. When it comes to composing applications in Android, there are several techniques and best practices that developers can follow to create high-quality, efficient, and maintainable code. Here are some of the key techniques: Model-View-Controller (MVC) architecture : One of the most common and widely used architectures for Android app development is the MVC architecture. This approach separates the application into three components: the model (data and business logic), the view (user interface), and the controller (handles user input and coordinates communication between the model and view).

73. Model-View- ViewModel (MVVM) architecture : Another popular architecture for Android app development is the MVVM architecture. This approach separates the application into three components: the model (data and business logic), the view (user interface), and the view model (acts as an intermediary between the model and view, providing data to the view and handling user input). Clean Architecture : This architecture separates the application into multiple layers, each with a specific responsibility, and each dependent only on the layers below it. This approach makes the code more modular, testable, and maintainable. Reactive Programming : Reactive programming is a programming paradigm that focuses on data streams and the propagation of changes. In Android app development, this can be implemented using frameworks such as RxJava and RxAndroid .

74. Dependency Injection : Dependency injection is a technique for providing objects with their dependencies without creating them directly. This can help to make the code more modular, testable, and maintainable. Kotlin Coroutines : Kotlin Coroutines are a concurrency framework for Android app development that makes it easier to write asynchronous code. Coroutines provide a simpler and more intuitive way to write asynchronous code than traditional threading models. Data Binding : Data binding is a technique for binding data directly to views in the user interface. This can help to simplify the code and make it more efficient. Jetpack Components: Jetpack is a set of libraries, tools, and guidance for Android app development that provides a standardized set of components for common tasks, such as navigation, data storage, and user interface design.

75. Dynamic Linking

76. Dynamic linking in Android is a process of linking libraries or other executable code to an Android application at runtime, rather than at compile time. This allows for smaller and more efficient APK sizes, as well as the ability to update libraries independently of the application. When an Android application is compiled, it includes references to external libraries or modules that it depends on . These references are typically resolved at compile time, resulting in a larger APK file size. With dynamic linking, these references are instead resolved at runtime, allowing for smaller APK files and reducing the application's memory footprint. The Android operating system provides a dynamic linker called "linker" which is responsible for linking shared libraries at runtime. The linker loads the necessary shared libraries into memory and resolves symbols referenced by the application. This process is transparent to the application and occurs automatically when the application is launched.

77. Android also supports the use of the Native Development Kit (NDK) to build and link native code libraries. NDK provides a set of tools and libraries to develop C and C++ code for Android, which can be compiled into shared libraries and linked dynamically to the Android application at runtime

78. Plug-ins and rules of thumb for using DLLs

79. DLLs (Dynamic Link Libraries) are not commonly used in Android development, as Android uses a different architecture from desktop operating systems like Windows. Instead, Android uses a modified version of the Java programming language, which relies on Java Archive (JAR) files to package and distribute code . However, there are some cases where you might want to use DLLs in Android development, such as when you're porting code from a desktop application or working with a third-party library that uses DLLs. Here are some tips and rules of thumb for using DLLs in Android:

80. Use the Android NDK : The Android NDK (Native Development Kit) is a set of tools that allow you to develop native applications for Android using C and C++. The NDK includes support for loading DLLs, which can be useful if you need to port code from a desktop application or work with a third-party library that uses DLLs. Use a cross-platform library : Instead of using a DLL, you might consider using a cross-platform library that works on both desktop and mobile platforms. Examples include Boost (a collection of libraries for C++), Xamarin (a platform for building native apps for iOS , Android, and Windows using C#), and Qt (a cross-platform development framework for C++). Be aware of compatibility issues : DLLs compiled for desktop operating systems may not work on Android, as Android uses a different architecture and API. Make sure to test any DLLs thoroughly before using them in an Android project.

81. Use a wrapper library : If you need to use a DLL in your Android project, you might consider creating a wrapper library that exposes the DLL's functionality using a cross-platform API. This can help to abstract away platform-specific details and make the code more portable. Follow best practices for security : When using DLLs in your Android project, it's important to follow best practices for security. For example, you should only load DLLs from trusted sources, and you should make sure to validate any user input before passing it to the DLL.

82. Example Calculator XML File <? xml version ="1.0" encoding ="utf-8" ?> < LinearLayout xmlns: android ="http://schemas.android.com/apk/res/android" xmlns: app ="http://schemas.android.com/apk/res-auto" xmlns: tools ="http://schemas.android.com/tools" android :layout_width =" match_parent " android :layout_height =" match_parent " android :layout_centerVertical ="true" android :layout_marginLeft ="30dp" android :layout_marginTop ="40dp" android :layout_marginRight ="30dp" android :layout_marginBottom ="20dp" android :orientation ="vertical" tools :context =". MainActivity " >

83. < ImageView android :id ="@+id/ imageView " android :layout_width ="147dp" android :layout_height ="123dp" android :layout_gravity ="center" android :baselineAlignBottoma ="false" android :textAlignment ="center" app :srcCompat ="@ drawable /calculator" /> < EditText android :id ="@+id/ etFirstValue " android :layout_width =" match_parent " android :layout_height =" wrap_content " android :layout_marginTop ="10dp" android :ems ="10" android :hint ="Enter First Numbr " android :inputType ="number" android :textSize ="24sp" />

84. < EditText android :id ="@+id/ etSecondValue " android :layout_width =" match_parent " android :layout_height =" wrap_content " android :layout_marginTop ="10dp" android :ems ="10" android :hint ="Enter Second Number" android :inputType ="number" android :textSize ="24sp" /> < TextView android :id ="@+id/ tvAns " android :layout_width =" match_parent " android :layout_height =" wrap_content " android :layout_marginTop ="10dp" android :layout_marginBottom ="10dp" android :paddingTop ="5dp" android :paddingBottom ="5dp" android :text ="Result" android :textSize ="24sp" />

85. < Button android :id ="@+id/ btnAdd " android :layout_width =" match_parent " android :layout_height =" wrap_content " android :layout_marginTop ="10dp" android :text ="@string/plus" android :textColor ="#FF5722" android :textSize ="30dp" android :textStyle ="bold" /> < Button android :id ="@+id/ btnSubtract " android :layout_width =" match_parent " android :layout_height =" wrap_content " android :layout_marginTop ="10dp" android :text ="@string/minus" android :textColor ="#FF5722" android :textSize ="30dp" android :textStyle ="bold" />

86. < Button android :id ="@+id/ btnMultiply " android :layout_width =" match_parent " android :layout_height =" wrap_content " android :layout_marginTop ="10dp" android :text ="@string/multiply" android :textColor ="#FF5722" android :textSize ="30dp" android :textStyle ="bold" /> < Button android :id ="@+id/ btnDivide " android :layout_width =" match_parent " android :layout_height =" wrap_content " android :layout_marginTop ="10dp" android :text ="@string/divide" android :textColor ="#FF5722" android :textSize ="30dp" android :textStyle ="bold" /> </ LinearLayout >

87. Java File package com.example.calculatordcsa ; import androidx.appcompat.app.AppCompatActivity ; import android.os.Bundle ; import android.view.View ; import android.webkit.WebView ; import android.widget.Button ; import android.widget.EditText ; import android.widget.TextView ; public class MainActivity extends AppCompatActivity { EditText etFirstValue , etSecondValue ; TextView tvAns ; Button add , subtract , multiply , divide ;

88. @Override protected void onCreate ( Bundle savedInstanceState ) { super .onCreate ( savedInstanceState ); setContentView ( R . layout . activity_main ); etFirstValue = findViewById ( R . id . etFirstValue ); etSecondValue = findViewById ( R . id . etSecondValue ); tvAns = findViewById ( R . id . tvAns ); add = findViewById ( R . id . btnAdd ); subtract = findViewById ( R . id . btnSubtract ); multiply = findViewById ( R . id . btnMultiply ); divide = findViewById ( R . id . btnDivide );

89. add .setOnClickListener ( new View . OnClickListener () { @Override public void onClick ( View view ) { int firstvalue , secondvalue , ans ; firstvalue = Integer . parseInt ( etFirstValue .getText (). toString ()); secondvalue = Integer . parseInt ( etSecondValue .getText (). toString ()); ans = firstvalue + secondvalue ; tvAns .setText ( " Ans ===" + ans ); } });

90. subtract .setOnClickListener ( new View . OnClickListener () { @Override public void onClick ( View view ) { int firstvalue , secondvalue , ans ; firstvalue = Integer . parseInt ( etFirstValue .getText (). toString ()); secondvalue = Integer . parseInt ( etSecondValue .getText (). toString ()); ans = firstvalue - secondvalue ; tvAns .setText ( " Ans ===" + ans ); } });

91. multiply .setOnClickListener ( new View . OnClickListener () { @Override public void onClick ( View view ) { int firstvalue , secondvalue , ans ; firstvalue = Integer . parseInt ( etFirstValue .getText (). toString ()); secondvalue = Integer . parseInt ( etSecondValue .getText (). toString ()); ans = firstvalue * secondvalue ; tvAns .setText ( " Ans ===" + ans ); } });

92. divide .setOnClickListener ( new View . OnClickListener () { @Override public void onClick ( View view ) { int firstvalue , secondvalue , ans ; firstvalue = Integer . parseInt ( etFirstValue .getText (). toString ()); secondvalue = Integer . parseInt ( etSecondValue .getText (). toString ()); ans = firstvalue / secondvalue ; tvAns .setText ( " Ans ===" + ans ); } }); }}

93. https://www.flaticon.com/ website for Icon https://data-flair.training/blogs/android-layout-and-views/