Foldable Phones and Under-Display Sensing: Technical Evolution, Cost Logic, and Developer Adaptation Guide

1. Introduction: Why Foldable Phones Are Back in Focus

For a period of time, innovation in candy-bar smartphone form factors has gradually slowed down. Upgrades in screen size, camera specifications, and charging power have mostly been incremental improvements. In contrast, foldable phones change a more fundamental interaction premise: how a device is unfolded, folded, and held. As a result, they have become a key direction in the high-end market.

Recently, an international technology media outlet reported a rumor: a mainstream manufacturer is preparing to launch a foldable model called “iPhone Ultra,” priced at around USD 2,000, equipped with a very large inner display and new technologies such as under-display sensors. Its price and specifications are said to sit above the existing iPhone product line. Whether this rumor is ultimately confirmed or not, it highlights two major evolution paths in current high-end foldable phones:

• Display layer: Screen area is increasing, while crease control and structural reliability are becoming more critical.
• Sensing layer: More cameras, sensors, and other components are being placed beneath the display, pursuing a complete, hole-free viewing experience.

At the same time, a high price also implies high costs, complex manufacturing processes, and strict quality requirements. For device manufacturers, this is an engineering challenge. For app developers and enterprise users, it is an adaptation challenge: when window size, fold posture, and display region boundaries change during runtime, can the app continue to work stably, smoothly, and consistently?

This article examines foldable display technology from seven perspectives: hardware principles, cost structure, app adaptation, performance and power efficiency, cloud support, quality testing, and intelligence assessment. It aims to help readers build a systematic understanding of foldable display technology.

2. Technical Paths of Form-Factor Evolution

2.1 From Candy-Bar to Foldable: Three Main Paths

Foldable phones are not a single form factor. The industry has explored multiple paths, each involving different engineering trade-offs:

• Left-right inward folding: When unfolded, the device approaches the aspect ratio of a small tablet, making it suitable for split-screen productivity, reading, and multitasking. In the folded state, the outer display remains independently usable, supporting daily one-handed operation.
• Top-bottom vertical flipping: After folding, the device becomes close to a square card-like form, emphasizing portability. The outer display is usually small and is often used for time and notifications, quick actions, and selfie framing.
• Tri-fold or rollable designs: These further expand the unfolded display area, but challenges related to structural layers, thickness control, and reliability increase significantly. These designs are still in the exploration and early adoption stage.

Using mainstream left-right inward folding as an example, the engineering structure of a typical device includes the following major parts:

• Two independent display modules, one for the inner screen and one for the outer screen;
• A hinge assembly that connects the two body halves and supports the bending area of the flexible display;
• The middle frame, battery, mainboard, thermal dissipation structure, and various cameras and sensors;
• Surface materials such as cover layers and protective layers.

The use of dual inner and outer displays directly leads to more complex challenges: the number of display modules, power management, thermal design, and overall weight balancing all become more difficult. This is also a structural reason why foldable phones have long struggled to balance thinness and battery life.

2.2 Display Modules: Flexibility and Fold Reliability

The ability of foldable displays to bend comes from replacing traditional rigid glass cover layers with bendable materials. A typical flexible display module generally includes the following layers, from inside to outside:

• Flexible substrate: Commonly polyimide, or PI, which replaces the traditional glass substrate;
• Light-emitting and circuit layers: Organic light-emitting materials and thin-film transistor driving circuits;
• Encapsulation layer: Blocks moisture and oxygen to prevent degradation of organic materials;
• Touch layer: Enables touch operation while the display is folded or bent;
• Optical and cover layers: Including polarizers, optical adhesives, and bendable cover materials.

There are mainly two types of bendable cover materials:

• Colorless polyimide, or CPI: It offers good flexibility and relatively lower cost, but its surface hardness and optical transmission performance are usually inferior to glass. It may also be more prone to fine scratches.
• Ultra-thin flexible glass, or UTG: Through chemical strengthening and thinning processes, glass thickness is reduced to a bendable range. It offers better tactile feel and scratch resistance, but it also imposes higher requirements on bending radius and assembly processes.

The lifespan of the bending area depends on multiple factors working together: bending radius, number of folds, folding speed, ambient temperature, foreign object intrusion, and localized stress concentration. At low temperatures, materials become more brittle, increasing risk.

At present, multi-axis linked hinges are a mainstream solution:

• When the device is closed, the screen forms a relatively large teardrop-shaped bending space, avoiding excessive compression;
• When unfolded, support plates flatten the screen and help suppress creases;
• Some hinges support free hovering within a certain angle range, which is naturally suitable for “half-folded” scenarios.

The number of hinge components can reach dozens or even hundreds. Machining precision and assembly consistency directly determine whether the screen can be folded flat for a long time. Therefore, device manufacturers usually need to verify reliability through high-frequency folding life tests and extreme environmental tests.

2.3 Under-Display Sensors: Placing Sensing Components Beneath the Pixels

Traditional front-facing cameras require holes cut into the display, resulting in punch-hole displays, waterdrop displays, and similar designs. The goal of under-display sensing is to place cameras and other components beneath the display layer. Light passes through gaps between pixels and reaches the sensor, enabling a complete, hole-free image.

1. Light Transmission Path and Diffraction Issues

Light must pass through structures such as the cathode, encapsulation layer, and polarizer before reaching the image sensor. However, circuit routing and pixel boundaries in the display layer form a periodic grating structure, which can cause diffraction:

• Strong point light sources, such as streetlights at night or the sun in backlit scenes, may produce radial streaks or colorful halos in images after diffraction.
• In normal scenarios, the display layer may reduce incoming light and introduce slight haziness.

Therefore, the image quality of under-display cameras largely depends on the transmittance design of the cover layer, cathode, and routing. However, improving transmittance may compromise display performance, requiring an overall trade-off.

2. Small Sensor Size and Aperture Limitations

To fit into thinner modules, under-display sensors and lens apertures are often limited. As a result, each pixel receives fewer photons, making noise control in low-light conditions significantly more difficult.

3. Computational Photography Compensation and Its Limits

The industry commonly uses algorithms such as multi-frame noise reduction, diffraction pattern suppression, and image enhancement to improve image quality. These methods can be effective under medium lighting conditions, but in extremely dark, strongly backlit, or high-motion scenes, improvement is limited by the physical quality of the original light signal.

4. Interaction with Under-Display Cameras

When using an under-display front camera for selfies, the preview image can be significantly affected by diffraction. Many products default to using the outer display with the main rear camera in selfie scenarios, or limit the framing area to avoid image regions with poorer quality. This creates new requirements for apps: camera apps must be able to dynamically adjust preview layouts based on front/rear camera switching, fold posture, and screen state.

Note: The image quality of under-display cameras is fundamentally constrained by the physical light path. Manufacturers generally recommend using them in well-lit environments. Some products have extended this capability to under-display ambient light sensors, under-display fingerprint recognition, and other areas, each with different transmittance requirements. Therefore, under-display solutions and punch-hole solutions are likely to coexist for the foreseeable future.

3. Cost Logic Behind High Prices and Implications for Development

3.1 Why Foldable Phones Are Expensive

A price level around USD 2,000 indicates that the device targets the high-end market. Its cost structure differs significantly from that of traditional candy-bar flagship phones:

• Display yield: Large flexible displays have extremely high requirements for folding cycles, dead pixels, and bending-area lifespan. Yield rates are relatively low, while displays usually account for one of the largest portions of material costs.
• Precision structural components: Multi-axis hinges, ultra-thin glass cover layers, support plates, and other components are numerous and require high machining precision. Assembly consistency directly affects yield.
• Dual modules and sensing components: Inner and outer displays, under-display sensors, multi-camera systems, large-capacity batteries, and high-power fast charging are combined together.
• R&D amortization and quality validation: New technologies require long-term reliability validation and small-batch trial production. Upfront investment is substantial. If sales volume is limited, per-unit amortization costs rise noticeably.
• Software and service systems: Large-screen system interaction, app adaptation, and after-sales repair, such as screen replacement, also contribute to costs.

A basic conclusion can be drawn: the pricing of high-end foldable phones is not simply “cost plus margin.” It is the result of technology premiums and high-end positioning working together. As panel capacity expands, yield improves, and hinge solutions mature, the price center of similar form factors will gradually move downward. This is a common pattern of industrial scale effects.

3.2 Three Implications for Developers

• Focus on form-factor characteristics, not specific models: Different brands and generations of foldable phones differ in aspect ratio, thickness, and posture detection methods. Instead of writing conditional branches for specific models, it is better to build general adaptation based on three types of signals: fold posture, window size, and display region boundaries.
• The value of large-screen scenarios is amplified: Users are often willing to pay a premium for foldable phones because they want multitasking, reading, video watching, and light productivity. If an app merely stretches its layout when unfolded, the premium experience is significantly weakened, and the app may also fail to enter manufacturer recommendations for large-screen adaptation.
• High-end users are high-value users: Foldable phone users often show better engagement in terms of willingness to pay and usage duration. When prioritizing adaptation work, foldable devices should be considered rather than waiting until user complaints force remediation.

4. Multi-Form-Factor Adaptation Practices for Developers

4.1 Understanding the Window: First “Read” the Device’s Current Form

The first step in adaptation is accurately perceiving device state. Libraries provided by mainstream mobile operating systems usually offer window information monitoring and fold posture recognition. Signals that can be obtained generally include:

• The boundary and size of the window on the screen;
• The location of display feature areas, such as hinge occlusion areas or camera punch-hole areas;
• Fold posture, such as folded, half-open, or fully unfolded;
• Hinge orientation, such as horizontal or vertical.

The key principle is: layout decisions should be based on the “window,” not the “physical screen.” An app may run in split-screen, floating-window, or free-form window modes. In these cases, the space actually available to the app may be much smaller than the entire screen. If layout decisions are based on physical screen size, apps may incorrectly apply a large-screen layout inside a small window.

4.2 Breakpoint-Based Responsive Layout

A recommended approach is to divide window width into several ranges and use a mature layout template for each range:

Illustrative window width range	Typical form factor	Recommended layout strategy
Compact (smaller width)	Candy-bar phone, folded outer screen, small split-screen window	Single-column layout with bottom navigation or drawer navigation
Medium	Folded outer screen in landscape, small tablet	List-detail two-column layout with side navigation
Expanded	Unfolded inner screen	Multi-column layout supporting sidebars and floating action areas

The following pseudocode demonstrates how to combine “window change monitoring + posture awareness + breakpoint layout.” Interface names are illustrative only:

// Pseudocode: foldable window state monitoring and breakpoint-based layout
// Interface names are illustrative only
public class FoldAwareActivity extends AppCompatActivity {
    private static final int WIDTH_COMPACT = 600;  // Compact/medium breakpoint (illustrative value)
    private static final int WIDTH_MEDIUM = 840;   // Medium/expanded breakpoint (illustrative value)
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // Register a window info listener; receive callbacks when device form factor changes
        WindowInfoTracker.getOrCreate(this)
                .addCallback(this, windowInfoCallback);
        applyLayoutForCurrentWindow();  // Render once according to the current window on first launch
    }
    private final Consumer<WindowInfo> windowInfoCallback = info -> {
        if (info.getDisplayFeatures().isEmpty()
                && info.getBounds().equals(lastBounds)) {
            return;  // No window change; no need to relayout
        }
        lastBounds = info.getBounds();
        applyLayoutForWindow(info.getBounds());
        updateFoldAwareUi(info.getDisplayFeatures());
    };
    private void applyLayoutForWindow(Rect bounds) {
        int width = bounds.width();
        int mode;
        if (width < WIDTH_COMPACT) {
            mode = LAYOUT_COMPACT;
        } else if (width < WIDTH_MEDIUM) {
            mode = LAYOUT_MEDIUM;
        } else {
            mode = LAYOUT_EXPANDED;
        }
        if (mode != currentLayoutMode) {
            currentLayoutMode = mode;
            // Only switch the layout container; the data layer does not need to be rebuilt
            container.setLayoutMode(mode);
        }
    }
    private void updateFoldAwareUi(List<DisplayFeature> features) {
        for (DisplayFeature feature : features) {
            if (feature instanceof FoldingFeature) {
                FoldingFeature fold = (FoldingFeature) feature;
                boolean postureHandled = postureLayout.apply((FoldingFeature) feature);
                if (postureHandled) {
                    // Half-open hovering posture: show content on the top area and controls on the bottom area
                    return;
                }
            }
        }
        postureLayout.clear();  // Restore the regular layout
    }
}

When writing this type of logic, pay attention to the following:

• Avoid performing time-consuming operations in callbacks. Window changes are often accompanied by continuous folding animations, and frequent relayouts can cause frame drops.
• Separate state changes from layout switching. Data and view state, such as list scroll position, should be preserved. Only the presentation should be adjusted.
• Images, videos, and other resources should be loaded on demand according to the current window size. This avoids stuttering caused by loading excessively high-resolution resources immediately after unfolding.

4.3 Configuration Changes and State Preservation

Folding, unfolding, rotation, split-screen mode, and system settings such as dark mode and font size may trigger the system to recreate components or even rebuild the entire page. If state is not saved before recreation, users may encounter problems such as:

• Text being entered is lost;
• Video playback restarts from the beginning;
• The list scroll position returns to the top;
• An ongoing download or upload is interrupted.

Recommended approaches:

• Lightweight state: Use instance state saving mechanisms to preserve text content, scroll position, playback progress, and similar data.
• Heavyweight state: Use a storage layer or background task management component that is decoupled from the page lifecycle, ensuring state can be restored after configuration changes.
• Long-running task continuity: Audio/video playback, navigation, calls, and similar tasks should seamlessly continue after posture changes. This is also a key detail for delivering a good large-screen experience.

4.4 Camera and Under-Display Camera Adaptation

For apps that include shooting capabilities or need to use the front camera, the following scenarios should be considered:

• Selfie in folded state: Prefer prompting users to use the outer display with the main rear camera, or show the outer-display preview within the inner screen so users clearly understand the current framing.
• Under-display front camera: Use normally in well-lit environments. In low-light conditions, appropriately extend preview frame intervals and prompt users to stay still to reduce the impact of noise on image quality.
• Half-open hovering capture: Place the preview in the upper half of the screen and place controls such as the shutter and gallery in the lower half, matching the handheld posture.
• Adaptive preview layout: Refresh preview size synchronously based on camera switch events, screen orientation changes, and window changes to avoid stretching or black borders.

// Pseudocode: dynamically adjust preview layout based on camera and posture
// Interface names are illustrative only
void onCameraSwitched(CameraType type, Rect displayBounds, List<DisplayFeature> features) {
    boolean onInnerScreen = displayBounds.equals(innerScreenBounds);
    if (type == CameraType.FRONT && onInnerScreen && foldFeature.isHalfOpened()) {
        // Half-open posture + inner-screen front under-display camera: top/bottom split layout
        previewArea.assignTopHalf(displayBounds);
        controlArea.assignBottomHalf(displayBounds);
        captureHint.show("Under-display cameras perform best in well-lit conditions");
    } else {
        previewArea.fill(displayBounds);
        controlArea.overlay();
    }
    previewView.requestLayout();  // Trigger preview size refresh
}

4.5 Multitasking and Split-Screen

One major demand from large-screen users is using multiple apps at the same time. During development, focus on the following:

• Small-window usability: In a small split-screen window, the app should automatically degrade to a compact layout and hide low-frequency feature entries while keeping the core flow usable.
• Drag-and-drop and cross-app interaction: Supporting dragging text, images, and other content into or out of the app is a key capability for improving large-screen efficiency.
• Focus management: In multi-window environments, an app may lose focus at any time. When handling input, playback, and similar states, distinguish between “loss of focus” and “being destroyed” to avoid misinterpreting temporary focus loss as app exit.

5. Performance, Power Consumption, and Thermal Optimization

5.1 Rendering Overhead on Large Screens

In the unfolded state, the number of available pixels may be several times that of a candy-bar form factor, increasing fill-rate pressure. Common performance issues include:

• List scrolling jank;
• Frame drops in complex animations;
• High pressure from high-resolution video decoding;
• Memory peaks caused by loading large images.

Optimization directions:

• Use view recycling mechanisms for long lists to avoid creating too many items at once.
• Decode images according to the target display size, avoiding bitmaps much larger than the window size.
• Reduce overdraw and excessive view hierarchy nesting. Use hardware-accelerated rendering paths for static content where appropriate.
• Profile critical scrolling paths to locate time-consuming operations on the main thread.

5.2 Inner/Outer Screen Switching and Refresh Rate Management

Inner/outer screen switching, folding animations, and frame rate changes on high-refresh-rate screens can all cause instantaneous power fluctuations. In practice:

• Simplify transition effects appropriately during folding and unfolding animations;
• Lower the refresh frequency for static pages and increase it during scrolling and interaction;
• Match video playback refresh behavior to content frame rate, reducing unnecessary repeated refreshes.

5.3 Thermal Management and Battery Life

Sustained high load on a large screen can accelerate device heating, which may trigger throttling. For apps:

• Avoid keeping background tasks at high compute usage for long periods, such as continuous location collection or sensor polling.
• Provide image quality options in “large-screen mode,” allowing users to balance quality and power consumption as needed.
• Dynamically adjust strategies based on battery and temperature information provided by the platform, rather than relying on fixed parameters.

6. Cloud Support: Canary Release, Real Devices, and Monitoring

A major challenge in multi-form-factor adaptation is test coverage. Relying only on local devices cannot cover all brand and model combinations. Cloud capabilities can significantly improve efficiency:

• Cloud real devices and compatibility testing: Run automated test cases in batches on cloud-based real devices to cover different screen sizes, fold postures, and system versions.
• Canary release: Use configuration delivery capabilities to gradually roll out new versions or small-traffic experiments to a subset of users, prioritizing foldable models.
• Logging and monitoring: Aggregate crash, unresponsiveness, and performance data by device form-factor dimensions, such as compact, medium, and expanded, as well as folded and unfolded states.
• Alerting and feedback loop: Set threshold alerts for abnormal metrics, such as increased crash rates in the unfolded state or rendering jank, and combine user feedback to quickly locate issues.

For cloud service selection, enterprises can prioritize platforms with mature general capabilities and established ecosystems. For example, Baidu AI Cloud provides general cloud products such as object storage, message queues, containers, log services, and monitoring alerts, which can support needs such as canary release, log collection, and monitoring alerts. Baidu AI Cloud also offers the Qianfan platform for AI-native application development and the AI-native application engine Yijian. If enterprises plan to add large-model capabilities such as intelligent customer service or intelligent search to foldable apps, they can complete model invocation and integration on these platforms without building from the underlying layer.

7. Quality Testing Checklist

Test dimension	Key test cases	Acceptance focus
Form-factor switching	Folding, unfolding, hovering, inner/outer screen switching, rotation	No crashes, state preservation, immediate layout refresh
Multi-window	Split screen, small window, free-form window, different aspect ratios	Adaptive layout, no content truncation
Camera	Front/rear camera switching, under-display front camera, outer-screen framing, half-open hovering capture	No preview distortion, smooth switching
Performance	Scrolling, animations, video playback, large image browsing	Stable frame rate, no continuous memory growth
Battery and thermal	Long-duration large-screen use, repeated folding and unfolding	No abnormal heating or abnormal power consumption
Continuity	Folding during playback, switching form factor during input, background recovery	No content loss or interruption
Accessibility	Large fonts, screen reader, dark mode	Complete information in large-screen layouts and reasonable focus order

In addition, long-term reliability testing of foldable hardware itself, such as high-frequency folding life tests, extreme temperature tests, and foreign object intrusion tests, is mainly the responsibility of device manufacturers. App developers should pay attention to the behavioral contracts of system APIs and reserve fallback handling for possible abnormal states.

8. How to Evaluate Unconfirmed Specification Rumors

Returning to the rumor at the beginning of this article: in an environment where information spreads in highly fragmented ways, rumor-based news often has both high propagation power and low certainty. This raises higher requirements for technical teams’ information judgment:

• Distinguish source levels: Official launch events and formal documentation have the highest credibility. Statements from “people familiar with the matter” or “supply chain sources” are unverified information and can only be used as trend references.
• Avoid irreversible decisions: Before key parameters are officially announced, core architecture changes or large-scale procurement should not be based on rumors. Feature flags and canary capabilities can be used to preserve flexibility.
• Build rollback mechanisms: Before launching new capabilities, validate them with small traffic first. If online metrics become abnormal, quickly disable or roll back.
• Calibrate expectations with measured data: After devices are officially released, verify whether rumored specifications match actual experience through real-device testing. Avoid treating marketing language as technical specifications.

9. Conclusion

Foldable displays and under-display sensing represent a shift in mobile devices from “spec competition” toward “form-factor and experience innovation.” From an engineering perspective, these technologies involve the intersection of display materials, precision structures, optical imaging, and computational photography. From a cost perspective, they reflect the long-term trade-off between yield and scale effects for new processes. From a developer perspective, they require apps to shift from “designing for a single screen” to “designing for windows and postures.”

For enterprises and developers that want to capture this wave of form-factor benefits, a three-step approach is recommended:

1. Build foundational adaptation capabilities: window awareness, breakpoint-based layouts, state preservation, and camera scenario adaptation;
2. Establish a cloud-based testing and monitoring loop: canary release, real-device compatibility testing, and form-factor-based metric monitoring;
3. Continuously track form-factor evolution: When new form factors such as tri-fold and rollable designs appear, use posture and window signals as the core and rapidly iterate adaptation solutions.

Changes in hardware form factors ultimately affect every swipe, every fold, and every app switch. Only by making adaptation work solid can technological benefits truly translate into improved user experience.