UI/UX and Components in Mobile Development: What They Are, Types, and How to Use

Design Systems: Material Design and Human Interface Guidelines

Each platform offers its own set of rules and components. For Android, this is Material Design, developed by Google in 2014. Material Design uses the metaphor of physical material — layers, shadows (Elevation), animated transitions, and adaptive layouts. Key principles include hierarchy through elevation, meaningful motion, and adaptability across different form factors. We recommend exploring Material Design 3 (Material You) — the latest version with dynamic theme and personalized colors.

Apple offers Human Interface Guidelines (HIG) — a set of rules for iOS, iPadOS, macOS, watchOS, and tvOS. HIG emphasizes clear typography (San Francisco), Safe Area to account for the Notch and Dynamic Island, gesture-based navigation, and consistency. Unlike Material Design, HIG does not use "layers" and Elevation — instead, it uses blur (vibrancy), shadows, and subtle separators. The full HIG documentation is regularly updated with new iOS releases.

At IT Sectr, we use both design systems depending on the client's platform. For cross-platform Flutter projects, we develop a unified design system that combines the best practices of Material Design and HIG. This approach preserves a native UX on each platform without code duplication.

Declarative UI Frameworks: SwiftUI and Jetpack Compose

The traditional approach to building UI is imperative layout via XML (Android) or Interface Builder / code (iOS). The modern alternative is declarative frameworks, where the developer describes how the interface should look in each state, and the framework handles updates.

Jetpack Compose (Android)

Jetpack Compose is a modern toolkit from Google for building native UI in Kotlin. Instead of XML layouts, Kotlin composable functions (@Composable) are used. Compose is fully declarative: when data changes, only the changed parts of the screen are redrawn. Example of a simple screen with text and a button:

@Composable
fun GreetingScreen() {
    var count = remember { mutableStateOf(0) }
    Column {
        Text(text = "Нажато: $count")
        Button(onClick = { count++ }) {
            Text("Нажми меня")
        }
    }
}

SwiftUI (iOS)

SwiftUI is Apple's declarative framework introduced in 2019. It works across all Apple platforms (iOS, iPadOS, macOS, watchOS, tvOS) through a unified API. SwiftUI uses View structures, @State and @Binding properties for data management, and modifiers for styling. The equivalent of the example above in SwiftUI:

struct GreetingView: View {
    @State private var count = 0
    var body: some View {
        VStack {
            Text("Нажато: \(count)")
            Button("Нажми меня") {
                count += 1
            }
        }
    }
}

Flutter Widgets

Flutter from Google uses its own widget library. Everything in Flutter is a widget — from padding to an entire screen. Widgets are divided into StatelessWidget (immutable) and StatefulWidget (with state). Basic containers are Container, Row, Column, Stack. Flutter does not use native platform components — it draws everything through the Skia Engine, ensuring a consistent look on both Android and iOS.

class GreetingWidget extends StatefulWidget {
    @override
    State createState() => _GreetingWidgetState();
}
class _GreetingWidgetState extends State<GreetingWidget> {
    int count = 0;
    @override
    Widget build(BuildContext context) {
        return Column(
            children: [
                Text('Нажато: $count'),
                ElevatedButton(
                    onPressed: () => setState(() => count++),
                    child: Text('Нажми меня'),
                ),
            ],
        );
    }
}

Native UI Components for Android and iOS

Despite the spread of declarative frameworks, understanding native components remains important for supporting legacy projects and deep customization.

Navigation

Navigation in Android is built on Activity (screen activities) and Fragment (fragments within one Activity). Jetpack Navigation Component simplifies transitions between screens through a navigation graph. In iOS, navigation is implemented via NavigationController — a stack of controllers with animated transitions. Tab Bar and Bottom Navigation enable switching between main sections of the app. Drawer (side menu) and Toolbar/ActionBar are used for additional actions. Android Navigation Component is recommended for all new projects.

Lists

For displaying large amounts of data, Android uses RecyclerView — an efficient container with ViewHolder reuse. The iOS equivalents are UITableView (vertical lists) and UICollectionView (grids). Jetpack Compose offers LazyColumn and LazyVerticalGrid, while SwiftUI provides List and LazyVStack/LazyHStack. The key advantage of Lazy components is rendering only visible elements.

Layouts and Positioning

The Android View System offers several Layout containers: ConstraintLayout (flexible constraint system), LinearLayout (linear arrangement), RelativeLayout (relative positioning), FrameLayout (layer stacking). In iOS, Core Auto Layout uses a system of constraints (NSLayoutConstraint) to describe element positioning. SwiftUI and Flutter use VStack/HStack/ZStack and Row/Column/Stack respectively.

Measurement Units and Responsive Layout

Mobile device UI components are displayed taking into account different pixel densities. To make the interface look the same on all screens, density-independent units are used.

Screen densities are classified as: mdpi (160 dpi, 1x), hdpi (240 dpi, 1.5x), xhdpi (320 dpi, 2x), xxhdpi (480 dpi, 3x), xxxhdpi (640 dpi, 4x). When preparing images, you need to create resources for all densities: icon.png, icon_hdpi.png, icon_xhdpi.png, and so on. Vector formats (VectorDrawable in Android, SF Symbols in iOS) solve the problem of multiple raster resources.

At IT Sectr, we use a scaling factor for exporting icons from Figma: we export at 1x, 2x, 3x for iOS and mdpi, hdpi, xhdpi, xxhdpi, xxxhdpi for Android. This ensures sharp display on all devices including tablets and foldable smartphones.

Modern UI Concepts: Dark Mode, Safe Area, Accessibility

Modern mobile app UI components must support a number of standards, without which the user experience would be incomplete.

Dark Mode / Light Mode

Dark Mode is a mandatory option in modern applications. Material Design 3 and iOS 13+ provide built-in dark theme support. It is important not to invert colors but to use separate color palettes: dark background, light text, reduced contrast for secondary elements. Automatic switching can be tied to the system theme of the device.

Safe Area and Notch / Dynamic Island Support

Modern iPhones have a Notch (cutout for the front camera) and Dynamic Island. Android devices also have cutouts and rounded corners (Corner Radius). Safe Area is the screen area guaranteed to be free of system elements (status bar, home indicator), navigation bar, and cutouts. iOS automatically applies Safe Area Insets; Android requires explicit checking via WindowInsets or DisplayCutout.

Accessibility (a11y)

Accessibility ensures app usability for people with disabilities. Key requirements: TalkBack (Android) and VoiceOver (iOS) support, correct contentDescription for ImageView, sufficient color contrast (minimum 4.5:1 for text), Dynamic Type (iOS) support for font scaling, vision-free navigation, and gesture alternatives. WCAG 2.1 is the international accessibility standard.

Globalization and Localization (i18n / l10n)

Internationalization (i18n) is preparing the app to support multiple languages and regional formats. Localization (l10n) is translating strings, dates, currencies, and cultural specifics. Android uses resource directories (values-ru, values-de), iOS uses Localizable.strings and XLIFF. Flutter supports flutter_localizations with ARB translation files.

Gestures and Interaction

Touch interaction includes many gestures: Tap, Long Press, Swipe, Pinch-to-Zoom, Pull-to-Refresh, Drag-and-Drop. Android uses GestureDetector, iOS uses UIGestureRecognizer. iOS also supports 3D Touch (Force Touch) and Haptic Touch with haptic feedback via the Taptic Engine.