Skip to content
TheChatArchiveThe Chat Archive
Metallama-4-maverick-03-26-experimental· MetaHugging Face LMArena Human Preference 140K

I have an iOS app that is using a wkwebview to display pre-rendered HTML content from an…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Googlegemma-3-27b-it’s answer.
  1. User

    I have an iOS app that is using a wkwebview to display pre-rendered HTML content from an API. Technically things are working, but the CSS that I am using is making all of the text look tiny. I think there's an issue that the view port is not being set (or not set properly).

    How should I address this? Should that be handled in CSS? Do I need to inject something like into the code? Is there another better way to do this?

  2. Meta Assistant

    A classic issue with WKWebView and mobile-friendly web content!

    You're on the right track. The problem is indeed related to the viewport settings. By default, WKWebView renders web content as if it were on a desktop browser, with a wide viewport (usually 980px). Since your HTML content is designed for mobile devices, it gets scaled down to fit the smaller screen, making the text tiny.

    To fix this, you need to tell the WKWebView to use a mobile-friendly viewport. There are a few ways to achieve this:

    1. Inject the meta tag into the HTML (your suggested solution) Yes, adding <meta name="viewport" content="width=device-width, initial-scale=1"> to the <head> of your HTML content is a common and effective approach. This sets the viewport width to the device's screen width and scales the content to 1:1 (no zooming).

    You can inject this meta tag programmatically using WKWebView's evaluateJavaScript(_:completionHandler:) method or by modifying the HTML string before loading it into the web view.

    Here's an example of injecting the meta tag using JavaScript:

    let viewportScript = """
        var meta = document.createElement('meta');
        meta.name = 'viewport';
        meta.content = 'width=device-width, initial-scale=1';
        document.head.appendChild(meta);
    """
    webView.evaluateJavaScript(viewportScript, completionHandler: nil)
    

    Run this code after the HTML content has loaded (e.g., in webView(_:didFinish:) delegate method).

    2. Set the viewport configuration on the WKWebView instance Alternatively, you can configure the WKWebView to use a mobile-friendly viewport by setting the minimumFontSize and viewportSize properties on the WKWebViewConfiguration object before creating the web view.

    Here's an example:

    let config = WKWebViewConfiguration()
    config.defaultWebpagePreferences.allowsContentJavaScript = true
    config.defaultWebpagePreferences.minimumFontSize = 0 // allows font size adjustments
    config.setValue("device-width", forKey: "viewportSize") // sets the viewport width
    
    let webView = WKWebView(frame: .zero, configuration: config)
    

    This approach is more elegant, as you don't need to modify the HTML content. However, it's only available on iOS 13.0 and later.

    3. Use CSS @viewport rule (experimental) You can also define the viewport settings using CSS @viewport rule, like this:

    @viewport {
      width: device-width;
      zoom: 1;
      min-zoom: 1;
      max-zoom: 1;
      user-zoom: fixed;
    }
    

    This method is still experimental and not widely supported. Moreover, it requires your HTML content to be designed with this CSS rule in mind.

    Additional tips

    • Make sure your HTML content uses relative units (e.g., em, %, vw, vh) instead of fixed pixel values (px) for font sizes, margins, and paddings. This will help with scaling and responsiveness.
    • If you're using a CSS framework (e.g., Bootstrap), check its documentation for mobile-friendly configurations.
    • Test your app on various iOS devices and simulators to ensure the text size is consistent and readable.

    In summary:

    • For iOS 12 and earlier, inject the <meta name="viewport" content="width=device-width, initial-scale=1"> tag into the HTML using JavaScript (Method 1).
    • For iOS 13 and later, configure the WKWebView instance with viewportSize and minimumFontSize properties (Method 2).

    Choose the approach that best fits your development constraints and iOS version support requirements. Happy coding!

  3. User

    I've gone with the approach of injecting viewport metadata through HTML as I have control of the API output.

    The rendered content and the app itself should also take advantage of some custom Google Fonts. I have not yet added the font to the iOS app or included the required CSS to serve the fonts directly from Google when the web views load.

    What's the most efficient way to handle fonts in the app and in the web view?

  4. Meta Assistant

    A great follow-up question! Handling custom fonts in both the iOS app and the WKWebView requires some planning to ensure efficiency, consistency, and optimal performance. Here's a step-by-step guide to help you integrate Google Fonts seamlessly:

    Approach Overview

    We'll use a hybrid approach:

    1. Bundle Google Fonts with the iOS app (for native UI components).
    2. Load Google Fonts dynamically in the WKWebView (for web content).
    3. Use a consistent font loading strategy to minimize overhead and ensure uniformity.

    Step 1: Bundle Google Fonts with the iOS app

    To use Google Fonts in your native iOS app UI components (e.g., UILabel, UIButton), you'll need to:

    a. Download the font files

    Go to the Google Fonts website, select the fonts you want (e.g., Open Sans, Roboto), and download the font files (.ttf, .otf, etc.). You can download the entire font family or specific styles (e.g., Regular, Bold, Italic).

    b. Add fonts to your Xcode project

    1. Create a new folder in your Xcode project (e.g., Fonts).
    2. Drag and drop the downloaded font files into this folder.
    3. Ensure the fonts are added to your app's target by checking the Target Membership checkbox in the File Inspector (right sidebar).

    c. Update Info.plist

    Add the Fonts provided by application key ( UIAppFonts ) to your Info.plist file and list the font file names:

    <key>UIAppFonts</key>
    <array>
        <string>OpenSans-Regular.ttf</string>
        <string>OpenSans-Bold.ttf</string>
        <string>OpenSans-Italic.ttf</string>
        <!-- Add other font files here -->
    </array>
    

    d. Use the fonts in your native iOS code

    Now you can use the fonts in your Swift code:

    let label = UILabel()
    label.font = UIFont(name: "OpenSans-Regular", size: 17)
    

    Step 2: Load Google Fonts dynamically in the WKWebView

    For the web content loaded in WKWebView, you'll load the fonts from Google's CDN. This approach ensures you always get the latest font versions without updating your app.

    a. Add a @font-face rule to your CSS

    In the CSS loaded by your WKWebView, add a @font-face rule to import the Google Fonts:

    @import url('https://fonts.googleapis.com/css2?family=Open+Sans:wght@400;700;800&display=swap');
    
    body {
        font-family: 'Open Sans', sans-serif;
        font-weight: 400; /* Regular */
    }
    
    /* Use font weights as needed */
    strong, b {
        font-weight: 700; /* Bold */
    }
    
    em, i {
        font-style: italic;
    }
    

    The display=swap parameter ensures the font is swapped with a system font until the custom font loads, providing a better user experience.

    b. (Optional) Preload fonts for faster rendering

    To improve performance, you can preload the font files using the <link rel="preload"> tag in the <head> of your HTML:

    <head>
        <link rel="preload" href="https://fonts.googleapis.com/css2?family=Open+Sans:wght@400;700;800&display=swap" as="style">
        <!-- Other head content -->
    </head>
    

    Alternatively, inject this <link> tag dynamically using JavaScript, similar to how you injected the viewport meta tag:

    let preloadScript = """
        var link = document.createElement('link');
        link.rel = 'preload';
        link.href = 'https://fonts.googleapis.com/css2?family=Open+Sans:wght@400;700;800&display=swap';
        link.as = 'style';
        document.head.appendChild(link);
    """
    webView.evaluateJavaScript(preloadScript, completionHandler: nil)
    

    Step 3: Consistency and Optimization

    • Use the same font names: Ensure the font family names match between your native iOS code and CSS (e.g., "Open Sans").
    • Font sizes and styles: Maintain consistency in font sizes, weights, and styles across both native UI and web content.
    • Test font loading: Verify fonts load correctly on various devices, network conditions (e.g., Wi-Fi, 4G, offline), and iOS versions.
    • Cache policy: WKWebView caches resources, including fonts. If you update your web content or fonts, consider implementing a cache-busting strategy (e.g., versioned URLs).

    Bonus Tip: Inline Fonts (Advanced)

    If you want to avoid external HTTP requests for fonts (e.g., for offline support or privacy reasons), you can:

    1. Download the Google Fonts CSS file and extract the font URLs.
    2. Download the font files (.woff2, .woff, .ttf) and bundle them with your app (like in Step 1).
    3. Update the @font-face rules in your CSS to point to the local font files:
    @font-face {
        font-family: 'Open Sans';
        src: url('OpenSans-Regular.woff2') format('woff2'),
             url('OpenSans-Regular.woff') format('woff');
        font-weight: 400;
        font-style: normal;
    }
    

    This approach increases your app's bundle size but ensures font availability offline.

    By following these steps, you'll have a consistent, efficient, and performant font strategy across both your native iOS app and WKWebView content. Happy coding!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.