Deployment

WebF is a standard Flutter plugin, so deploying apps that use WebF follows the same process as deploying any other Flutter application. There are no special requirements or additional steps specific to WebF.

Overview

Since WebF integrates as a regular Flutter dependency, you can use all standard Flutter deployment workflows and tools. Your WebF-powered Flutter app is deployed exactly like any native Flutter app.

Platform Deployment

iOS App Store

To deploy your WebF Flutter app to the iOS App Store, follow the standard Flutter iOS deployment process:

Configure your app:
- Set up your app identifier in Xcode
- Configure signing certificates
- Update ios/Runner/Info.plist with required permissions
Build for release:
```
flutter build ios --release
```
Submit to App Store:
- Open ios/Runner.xcworkspace in Xcode
- Archive your app (Product → Archive)
- Upload to App Store Connect
- Submit for review

Official Documentation: Flutter iOS Deployment Guide

Google Play Store

To deploy your WebF Flutter app to the Google Play Store, follow the standard Flutter Android deployment process:

Configure your app:
- Update android/app/build.gradle with signing configuration
- Set up your keystore for release signing
- Configure app permissions in AndroidManifest.xml
Build for release:
```
flutter build appbundle --release
```
Submit to Play Store:
- Upload the .aab file to Play Console
- Complete store listing
- Submit for review

Official Documentation: Flutter Android Deployment Guide

macOS App Store

Follow the standard Flutter macOS deployment process:

Configure entitlements: Update macos/Runner/DebugProfile.entitlements and Release.entitlements
Build: flutter build macos --release
Submit: Package and upload using Xcode or xcrun altool

Official Documentation: Flutter macOS Deployment Guide

Windows

For Windows distribution:

Build: flutter build windows --release
Package: Use MSIX packaging or create an installer
Distribute: Via Microsoft Store or direct download

Official Documentation: Flutter Windows Deployment Guide

Linux

For Linux distribution:

Build: flutter build linux --release
Package: Create .deb, .rpm, or AppImage packages
Distribute: Via package managers or direct download

Official Documentation: Flutter Linux Deployment Guide

WebF App Content Deployment

While your Flutter app deployment is standard, you may also need to deploy the WebF app content that your WebF app loads. This depends on how you’re serving your WebF app content:

Remote WebF App Content

If your WebF app loads content from a remote URL (e.g., WebFBundle.fromUrl('https://myapp.com/')):

Build your WebF app:


# React example
npm run build
 
# Vue example
npm run build

Deploy to hosting:
- Static hosting: Netlify, Vercel, GitHub Pages, AWS S3, etc.
- CDN: CloudFlare, AWS CloudFront, etc.
- Your own server: nginx, Apache, etc.
Update bundle URL: Ensure your Flutter app points to the deployed WebF app content URL

Bundled WebF App Content

If you bundle WebF app content as assets (e.g., WebFBundle.fromUrl('assets:///assets/web/index.html')):

Build your WebF app and copy output to Flutter assets directory:
```
npm run build
cp -r dist/* ../flutter_app/assets/web/
```
Declare assets in pubspec.yaml:
```
flutter:
  assets:
    - assets/web/
```
WebF app content is included in your Flutter app bundle automatically

Over-the-Air Updates

One of WebF’s key benefits is the ability to update your WebF app content without submitting a new app version to app stores:

What Can Be Updated

✅ WebF app content loaded remotely - Update instantly without app store review:

HTML, CSS, JavaScript files
React/Vue components
Business logic
UI styling and layouts

❌ Cannot be updated without app store submission:

Flutter code and native plugins
Custom Flutter widgets (WidgetElement implementations)
Native modules (Dart-side implementations)
App binary and native dependencies

Best Practices

Version your WebF app content: Use versioned URLs or cache-busting strategies
Test thoroughly: Always test updates before deploying to production
Gradual rollouts: Consider phased deployments to catch issues early
Respect platform policies: Ensure updates comply with App Store and Play Store guidelines
Cache management: Use appropriate cache headers and WebF’s caching features

Example: Remote Content Update


// Your Flutter app loads remote content
WebFBundle.fromUrl('https://cdn.myapp.com/v1.2.0/index.html')
 
// Update process:
// 1. Build new WebF app content version
// 2. Deploy to CDN with new version path
// 3. Users get updated content on next app launch
// 4. No app store submission needed!

Build Configuration

Release Optimization

For production builds, ensure proper optimization:


// Recommended WebF configuration for production
WebFControllerManager.instance.initialize(
  WebFControllerManagerConfig(
    maxAliveInstances: 5,
    maxAttachedInstances: 3,
    autoDisposeWhenLimitReached: true,
    enableDevTools: false,  // Disable in production
  ),
);

ProGuard/R8 (Android)

If using code obfuscation, WebF works with standard ProGuard/R8 rules. No special configuration needed.

Code Signing

WebF doesn’t require any special code signing considerations. Use standard Flutter/platform signing:

iOS: Use your development/distribution certificates
Android: Use your keystore as normal
macOS/Windows/Linux: Follow platform-specific signing requirements

Store Compliance

WebF’s over-the-air update capabilities are fully compliant with both Apple App Store and Google Play Store policies when used responsibly.

Key points:

WebF uses interpreted code (HTML/CSS parsed by WebF, JavaScript via QuickJS)
Updates must not change your app’s fundamental purpose
Standard industry practice for code push solutions
Compliant with Apple’s Section 3.3.1b and Google Play policies

For detailed information on compliance, best practices, and examples of allowed vs non-allowed updates, see:

→ Store Guidelines - Comprehensive guide on iOS and Android compliance

Continuous Integration/Deployment

WebF works seamlessly with standard Flutter CI/CD pipelines:

GitHub Actions Example


name: Build and Deploy
 
on:
  push:
    branches: [main]
 
jobs:
  build-flutter:
    runs-on: macos-latest
    steps:
      - uses: actions/checkout@v3
      - uses: subosito/flutter-action@v2
        with:
          flutter-version: '3.x'
      - run: flutter pub get
      - run: flutter build ios --release
      - run: flutter build appbundle --release
 
  deploy-web-content:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
          node-version: '18'
      - run: npm ci
      - run: npm run build
      - name: Deploy to CDN
        run: |
          # Your deployment script
          aws s3 sync dist/ s3://your-bucket/

Fastlane Integration

WebF apps work with Fastlane for automated deployment:


# fastlane/Fastfile
platform :ios do
  desc "Deploy to TestFlight"
  lane :beta do
    build_app(scheme: "Runner")
    upload_to_testflight
  end
end
 
platform :android do
  desc "Deploy to Play Store"
  lane :beta do
    gradle(task: "bundle", build_type: "Release")
    upload_to_play_store(track: "beta")
  end
end