Mobile Programming 2 - 1`st Periodical Examination

5 Phases of the Mobile Software Development Lifecycle

• Inception

• Design

• Development
• Stabilization

• Deployment

Inception

All apps start with an idea. That idea is usually refined into a solid basis for an application.

Design

Consists of defining the app's User Experience (UX), such as what the general layout is, how it works, etc., as well as turning the UX into a proper User Interface (UI) design.

Development

Usually the most resource-intensive phase, this is the actual building of the application.

Stabilization

When development is far enough, Quality Assurance (QA) usually begins testing the application and bugs are fixed. Often, an application will go into a limited beta phase in which a wider user audience is given a chance to use it, provide feedback, and inform changes.

Deployment

In this phase, applications and updates are delivered from developers to users.

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

Is a cross-platform framework for creating native mobile and desktop apps with C# and XAML. It allows you to develop apps that can run on Android, iOS, macOS, and Windows from a single shared code-base.

It provides a single framework for building the UIs for mobile and desktop apps.

More about .NET MAUI

• v.NET MAUI unifies Android, iOS, macOS, and Windows APIs into a single API that allows a write-once run-anywhere developer experience while providing deep access to every aspect of each native platform.

• .NET provides a series of platform-specific frameworks for creating apps: .NET Android, .NET iOS, .NET macOS, and Windows UI 3 (WinUI 3) library. These frameworks all have access to the same .NET Base Class Library (BCL).

• BCL abstracts the details of the underlying platform away from your code. The BCL depends on the .NET runtime to provide the execution environment for your code.

• For Android, iOS, and macOS, the environment is implemented by Mono, an implementation of the .NET runtime. On Windows, .NET CoreCLR provides the execution environment.

• The various platforms have different ways of defining the user interface for an app, and they provide varying models for specifying how the elements of a user interface communicate and interoperate. You can craft the UI for each platform separately using the appropriate platform-specific framework (.NET Android, .NET iOS, .NET macOS, or WinUI 3), but this approach requires you to maintain a code-base for each individual family of devices.

.NET MAUI Features

An elaborate layout engine for designing pages.

• Multiple page types for creating rich navigation types, like drawers.

• Support for data-binding, for more elegant and maintainable development patterns.

• The ability to customize handlers to enhance how UI elements are presented.

• Cross-platform APIs for accessing native device features. These APIs enable apps to access device features such as the GPS, the accelerometer, and battery and network states.

• Cross-platform graphics functionality, that provides a drawing canvas that supports drawing and painting shapes and images, compositing operations, and graphical object transforms.

• A single project system that uses multi-targeting to target Android, iOS, macOS, and Windows.

• .NET hot reload, so that you can modify both your XAML and your managed source code while the app is running, then observe the result of your modifications without rebuilding the app.

.NET MAUI for Accessing Device Features

• Access to sensors, such as the accelerometer, compass, and gyroscope on devices

• Ability to check the device's network connectivity state and detect changes.

• Provide information about the device the app is running on.

• Copy and paste text to the system clipboard between apps.

• Pick single or multiple files from the device.

• Store data securely as key/value pairs.

• Utilize built-in text-to-speech engines to read text from the device.

• Initiate browser-based authentication flows that listen for a callback to a specific app-registered URL.

.NET MAUI Single Project Features

• A single shared project that can target Android, iOS, macOS, and Windows.

• A simplified debug target selection for running your .NET MAUI apps.

• Shared resource files within the single project.

• A single app manifest that specifies the app title, id, and version.

• Access to platform-specific APIs and tools when required.

• A single cross-platform app entry point.

.NET MAUI Project Initially Contains:

• MauiProgram.cs
• App.xaml and App.xaml.cs
• AppShell.xaml and AppShell.xaml.cs
• MainPage.xaml and MainPage.xaml.cs

MauiProgram.cs

Contains the code for creating and configuring the Application object.

App.xaml and App.xaml.cs

Provide UI resources and create the initial window for the application.

AppShell.xaml and AppShell.xaml.cs

Specify the initial page for the application and handle the registration of pages for navigation routing.

MainPage.xaml and MainPage.xaml.cs

Define the layout and UI logic for the page displayed by default in the initial window

App Class

Represents the .NET MAUI application as a whole. It inherits a default set of behaviors from Microsoft.Maui.Controls.Application. It is instantiated and loaded by the bootstrap code for each platform.

The App Class Contains

Methods for handling life-cycle events, including when the app is sent to the background.

Methods for creating new Windows for the application. The .NET MAUI application, by default, has a single window but can create and launch additional windows, which is helpful in desktop and tablet applications.

Shell

Reduces the complexity of app development by providing the fundamental features that most apps require, including:

• A single place to describe the visual hierarchy of an app.

• A common navigation user experience.

• A URI-based navigation scheme that permits navigation to any page in the app.

• An integrated search handler.

Visual hierarchy of the app is described in a class that subclasses the Shell class

• FlyoutItem or TabBar
• Tab
• ShellContent

FlyoutItem

Represents one or more items in the flyout and should be used when the navigation pattern for the app requires a flyout.

TabBar

Represents the bottom tab bar and should be used when the navigation pattern for the app begins with bottom tabs and doesn't require a flyout.

Tab

Represents grouped content, navigable by bottom tabs.

ShellContent

Represents the ContentPage objects for each tab.

Pages

Are the root of the UI hierarchy in .NET MAUI inside of a Shell.

.NET MAUI Built In Pages

• TabbedPage
• FlyoutPage
• NavigationPage

TabbedPage

This is the root page used for tab navigation. A tabbed page contains child page objects, one for each tab.

FlyoutPage

This page enables the implementation of a master/detail style presentation. It contains a list of items. When selecting an item, a view displaying the details for that item appears

NavigationPage

This page provides a hierarchical navigation experience where you can navigate through pages, forwards and backwards, as desired.

View

enables users to retrieve and present data in a specific manner.

ContentView,

The default view for a content page which displays items as-is. If the view is shrunk, items may disappear from the display until the view is resized.

ScrollView

Enables the display of items in a scrolling window; if the window is shrunk, items will be displayed by scrolling up and down.

CarouselView

Is a scrollable view that lets the user swipe through a collection of items.

CollectionView

Can retrieve data from a named data source and present each item using a template as a format. There are many other types of views available as well.

Layout

Defines the rules by which the controls are displayed relative to each other. It is also a control so it can be added to a view.

Common Controls Used to Define Layouts

• VerticalStackLayout

• HorizontalStackLayout
• AbsoluteLayout
• FlexLayout
• Grid

VerticalStackLayout and HorizontalStackLayou

optimized stack layouts that lay out controls in a top-to-bottom or left-to-right stack. A StackLayout is also available, which has a property named StackOrientation, which can be set to Horizontal or Vertical.

AbsoluteLayout

Which is used to set exact coordinates for controls.

FlexLayout

Is similar to StackLayout, except that it enables wrapping the child controls it contains if they do not fit in a single row or column. This layout also provides options for alignment and adapting to different screen sizes.

Grid

Which positions its child elements in a grid of rows and columns.

Markup Language

Is a computer language that is used to introduce various elements in a document. Elements are described using predefined tags.

Extensible Application Markup Language (XAML

is a declarative language created by Microsoft that is based on XML. It was designed to simplify the process of creating the UI in applications.

ContentPage

The root element of a XAML document.

Button

Is the most fundamental interactive control. It controls a defined Clicked event that is fired once the it is tapped.

RadioButton

It is a type of button that allows users to select one option from a set.

SearchBar

It is a user input control used to initiate a search.

SearchButtonPressed (Event Handler)

Is called when the user either clicks the search button or presses the enter key.

TextChanged (Event Handler)

Is called anytime the text in the query box is changed

Points

The values on iOS

DPI (density-independent pixels)

Values for Android

Orientation

represents the direction in which child views are positioned. The default value of this property is Vertical.

Spacing

Indicates the amount of space between each child view. The default value of this property is 0.