id
stringlengths 14
17
| text
stringlengths 23
1.11k
| source
stringlengths 35
114
|
|---|---|---|
27bdf6947950-7 | Let’s assume you built a Flutter module at
some/path/my_flutter, and then run:
cd some/path/my_flutter
flutter build aar
Then, follow the on-screen instructions to integrate.
More specifically, this command creates
(by default all debug/profile/release modes)
a local repository, with the following files:
To depend on the AAR, the host app must be able
to find these files.
To do that, edit app/build.gradle in your host app
so that it includes the local repository and the dependency:
android
// ...
repositories
maven
url
'some/path/my_flutter/build/host/outputs/repo'
// This is relative to the location of the build.gradle file
// if using a relative path.
maven
url | https://docs.flutter.dev/development/add-to-app/android/project-setup/index.html |
27bdf6947950-8 | // if using a relative path.
maven
url
'https://storage.googleapis.com/download.flutter.io'
dependencies
// ...
debugImplementation
'com.example.flutter_module:flutter_debug:1.0'
profileImplementation
'com.example.flutter_module:flutter_profile:1.0'
releaseImplementation
'com.example.flutter_module:flutter_release:1.0'
Important:
If you’re located in China, use a mirror site such as
https://[a mirror site]/download.flutter.io rather than the
storage.googleapis.com domain directly. See our
Using Flutter in China page for information on mirrors.
Tip:
You can also build an AAR for your Flutter module in Android Studio using
the Build > Flutter > Build AAR menu. | https://docs.flutter.dev/development/add-to-app/android/project-setup/index.html |
27bdf6947950-9 | Your app now includes the Flutter module as a dependency.
You can follow the next steps in the
Adding a Flutter screen to an Android app.
Option B - Depend on the module’s source code
This option enables a one-step build for both your
Android project and Flutter project. This option is
convenient when you work on both parts simultaneously
and rapidly iterate, but your team must install the
Flutter SDK to build the host app.
Include the Flutter module as a subproject in the host app’s
settings.gradle:
// Include the host app project.
include
':app'
// assumed existing content
setBinding
new
Binding
([
gradle:
this
]))
// new
evaluate
new
File | https://docs.flutter.dev/development/add-to-app/android/project-setup/index.html |
27bdf6947950-10 | evaluate
new
File
// new
settingsDir
parentFile
// new
'my_flutter/.android/include_flutter.groovy'
// new
))
// new
Assuming my_flutter is a sibling to MyApp.
The binding and script evaluation allows the Flutter
module to include itself (as :flutter) and any
Flutter plugins used by the module (as :package_info,
:video_player, etc) in the evaluation context of
your settings.gradle.
Introduce an implementation dependency on the Flutter
module from your app:
dependencies
implementation
project
':flutter'
Your app now includes the Flutter module as a dependency.
You can follow the next steps in the Adding a Flutter screen to an Android app. | https://docs.flutter.dev/development/add-to-app/android/project-setup/index.html |
2a661944e312-0 | Debugging your add-to-app module
Add Flutter to existing app
Debugging
Debugging your add-to-app module
Debugging
Terminal
VS Code
IntelliJ / Android Studio
Debugging your add-to-app module
Once you’ve integrated the Flutter module to your project and used Flutter’s
platform APIs to run the Flutter engine and/or UI,
you can then build and run your Android or iOS app the same way
you run normal Android or iOS apps.
However, Flutter is now powering the UI in places where you’re showing a
FlutterActivity or FlutterViewController.
Debugging | https://docs.flutter.dev/development/add-to-app/debugging/index.html |
2a661944e312-1 | Debugging
You may be used to having your suite of favorite Flutter debugging tools
available to you automatically when running flutter run or an equivalent
command from an IDE. But you can also use all your Flutter
debugging functionalities such as hot reload, performance
overlays, DevTools, and setting breakpoints in add-to-app scenarios.
These functionalities are provided by the flutter attach mechanism.
flutter attach can be initiated through different pathways,
such as through the SDK’s CLI tools,
through VS Code or IntelliJ/Android Studio.
flutter attach can connect as soon as you run your FlutterEngine, and
remains attached until your FlutterEngine is disposed. But you can invoke
flutter attach before starting your engine. flutter attach waits for
the next available Dart VM that is hosted by your engine.
Terminal
Run flutter attach or flutter attach -d deviceId to attach from the terminal.
VS Code | https://docs.flutter.dev/development/add-to-app/debugging/index.html |
2a661944e312-2 | VS Code
Select the correct device using the status bar in VS Code, then run the Flutter: Attach to Flutter on Device command from the command palette.
Alternatively, create a .vscode/launch.json file in your Flutter module project to enable attaching using the Run > Start Debugging command or F5:
name
Flutter: Attach
request
attach
type
dart
IntelliJ / Android Studio
Select the device on which the Flutter module runs so flutter attach filters for the right start signals. | https://docs.flutter.dev/development/add-to-app/debugging/index.html |
f7adf141f53b-0 | Add Flutter to existing app
Add Flutter to existing app
Add-to-app
Supported features
Add to Android applications
Add to iOS applications
Get started
API usage
Limitations
Add-to-app
It’s sometimes not practical to rewrite your entire application in
Flutter all at once. For those situations,
Flutter can be integrated into your existing
application piecemeal, as a library or module.
That module can then be imported into your Android or iOS
(currently supported platforms) app to render a part of your
app’s UI in Flutter. Or, just to run shared Dart logic.
In a few steps, you can bring the productivity and the expressiveness of
Flutter into your own app. | https://docs.flutter.dev/development/add-to-app/index.html |
f7adf141f53b-1 | The add-to-app feature supports integrating multiple instances of any screen size.
This can help scenarios such as a hybrid navigation stack with mixed
native and Flutter screens, or a page with multiple partial-screen Flutter
views.
Having multiple Flutter instances allows each instance to maintain
independent application and UI state while using minimal
memory resources. See more in the multiple Flutters page.
Supported features
Add to Android applications
Auto-build and import the Flutter module by adding a
Flutter SDK hook to your Gradle script.
Build your Flutter module into a generic
Android Archive (AAR) for integration into your
own build system and for better Jetifier interoperability
with AndroidX.
FlutterEngine API for starting and persisting
your Flutter environment independently of attaching a
FlutterActivity/FlutterFragment etc.
Android Studio Android/Flutter co-editing and module
creation/import wizard.
Java and Kotlin host apps are supported. | https://docs.flutter.dev/development/add-to-app/index.html |
f7adf141f53b-2 | Java and Kotlin host apps are supported.
Flutter modules can use Flutter plugins to interact
with the platform.
Support for Flutter debugging and stateful hot reload by
using flutter attach from IDEs or the command line to
connect to an app that contains Flutter.
Add to iOS applications
Auto-build and import the Flutter module by adding a Flutter
SDK hook to your CocoaPods and to your Xcode build phase.
Build your Flutter module into a generic iOS Framework
for integration into your own build system.
FlutterEngine API for starting and persisting
your Flutter environment independently of attaching a
FlutterViewController.
Objective-C and Swift host apps supported.
Flutter modules can use Flutter plugins to interact
with the platform.
Support for Flutter debugging and stateful hot reload by
using flutter attach from IDEs or the command line to
connect to an app that contains Flutter. | https://docs.flutter.dev/development/add-to-app/index.html |
f7adf141f53b-3 | See our add-to-app GitHub Samples repository
for sample projects in Android and iOS that import
a Flutter module for UI.
Get started
To get started, see our project integration guide for
Android and iOS:
Android
iOS
API usage
After Flutter is integrated into your project,
see our API usage guides at the following links:
Android
iOS
Limitations
Packing multiple Flutter libraries into an
application isn’t supported.
Plugins that don’t support FlutterPlugin might have unexpected
behaviors if they make assumptions that are untenable in add-to-app
(such as assuming that a Flutter Activity is always present).
On Android, the Flutter module only supports AndroidX applications. | https://docs.flutter.dev/development/add-to-app/index.html |
dfaec9f3ec15-0 | Adding a Flutter screen to an iOS app
Add Flutter to existing app
Adding Flutter to iOS
Add a Flutter screen
Start a FlutterEngine and FlutterViewController
Create a FlutterEngine
Show a FlutterViewController with your FlutterEngine
Alternatively - Create a FlutterViewController with an implicit FlutterEngine
Using the FlutterAppDelegate
Creating a FlutterAppDelegate subclass
If you can’t directly make FlutterAppDelegate a subclass
Launch options
Dart entrypoint
Dart library
Route
Other
This guide describes how to add a single Flutter screen to an existing iOS app.
Start a FlutterEngine and FlutterViewController
To launch a Flutter screen from an existing iOS, you start a
FlutterEngine and a FlutterViewController. | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-1 | The FlutterEngine serves as a host to the Dart VM and your Flutter runtime,
and the FlutterViewController attaches to a FlutterEngine to pass
input events into Flutter and to display frames rendered by the
FlutterEngine.
The FlutterEngine may have the same lifespan as your
FlutterViewController or outlive your FlutterViewController.
Tip:
It’s generally recommended to pre-warm a long-lived
FlutterEngine for your application because:
The first frame appears faster when showing the FlutterViewController.
Your Flutter and Dart state will outlive one FlutterViewController.
Your application and your plugins can interact with Flutter and your Dart
logic before showing the UI.
See Loading sequence and performance
for more analysis on the latency and memory
trade-offs of pre-warming an engine.
Create a FlutterEngine
Where you create a FlutterEngine depends on your host app. | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-2 | Where you create a FlutterEngine depends on your host app.
SwiftUI
UIKit-Swift
UIKit-ObjC
In this example, we create a FlutterEngine object inside a SwiftUI ObservableObject.
We then pass this FlutterEngine into a ContentView using the
environmentObject() property.
In MyApp.swift:
import
SwiftUI
import
Flutter
// The following library connects plugins with iOS platform code to this app.
import
FlutterPluginRegistrant
class
FlutterDependencies
ObservableObject
let
flutterEngine
FlutterEngine
name
"my flutter engine"
init
(){ | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-3 | "my flutter engine"
init
(){
// Runs the default Dart entrypoint with a default Flutter route.
flutterEngine
run
()
// Connects plugins with iOS platform code to this app.
GeneratedPluginRegistrant
register
with
self
flutterEngine
);
@main
struct
MyApp
App
// flutterDependencies will be injected using EnvironmentObject.
@StateObject
var
flutterDependencies
FlutterDependencies
()
var
body
some
Scene
WindowGroup
ContentView
()
environmentObject | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-4 | ContentView
()
environmentObject
flutterDependencies
As an example, we demonstrate creating a
FlutterEngine, exposed as a property, on app startup in
the app delegate.
In AppDelegate.swift:
import
UIKit
import
Flutter
// The following library connects plugins with iOS platform code to this app.
import
FlutterPluginRegistrant
@UIApplicationMain
class
AppDelegate
FlutterAppDelegate
// More on the FlutterAppDelegate.
lazy
var
flutterEngine
FlutterEngine
name
"my flutter engine"
override
func
application
application
UIApplication | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-5 | application
application
UIApplication
didFinishLaunchingWithOptions
launchOptions
UIApplication
LaunchOptionsKey
Any
]?)
>
Bool
// Runs the default Dart entrypoint with a default Flutter route.
flutterEngine
run
();
// Connects plugins with iOS platform code to this app.
GeneratedPluginRegistrant
register
with
self
flutterEngine
);
return
super
application
application
didFinishLaunchingWithOptions
launchOptions
); | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-6 | launchOptions
);
In this example, we create a FlutterEngine
object inside a SwiftUI ObservableObject.
We then pass this FlutterEngine into a
ContentView using the environmentObject() property.
In AppDelegate.h:
@import
UIKit
@import
Flutter
@interface
AppDelegate
FlutterAppDelegate
// More on the FlutterAppDelegate below.
@property
nonatomic
strong
FlutterEngine
flutterEngine
@end
In AppDelegate.m:
// The following library connects plugins with iOS platform code to this app.
#import <FlutterPluginRegistrant/GeneratedPluginRegistrant.h>
#import "AppDelegate.h"
@implementation | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-7 | #import "AppDelegate.h"
@implementation
AppDelegate
BOOL
application
:(
UIApplication
application
didFinishLaunchingWithOptions
:(
NSDictionary
UIApplicationLaunchOptionsKey
id
launchOptions
self
flutterEngine
[[
FlutterEngine
alloc
initWithName
@"my flutter engine"
];
// Runs the default Dart entrypoint with a default Flutter route.
self
flutterEngine
run
];
// Connects plugins with iOS platform code to this app.
GeneratedPluginRegistrant
registerWithRegistry
self | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-8 | registerWithRegistry
self
flutterEngine
];
return
super
application
application
didFinishLaunchingWithOptions
launchOptions
];
@end
Show a FlutterViewController with your FlutterEngine
SwiftUI
UIKit-Swift
UIKit-ObjC
FlutterViewController.
The
import
SwiftUI
import
Flutter
struct
ContentView
View
// Flutter dependencies are passed in an EnvironmentObject.
@EnvironmentObject
var
flutterDependencies
FlutterDependencies
// Button is created to call the showFlutter function when pressed.
var | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-9 | var
body
some
View
Button
"Show Flutter!"
showFlutter
()
func
showFlutter
()
// Get the RootViewController.
guard
let
windowScene
UIApplication
shared
connectedScenes
first
where
$0
activationState
==
foregroundActive
&&
$0
is
UIWindowScene
})
as?
UIWindowScene
let
window
windowScene
windows
first
where | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-10 | windows
first
where
isKeyWindow
),
let
rootViewController
window
rootViewController
else
return
// Create the FlutterViewController.
let
flutterViewController
FlutterViewController
engine
flutterDependencies
flutterEngine
nibName
nil
bundle
nil
flutterViewController
modalPresentationStyle
overCurrentContext
flutterViewController
isViewOpaque
false
rootViewController
present
flutterViewController
animated
true
FlutterViewController.
The
import
UIKit | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-11 | FlutterViewController.
The
import
UIKit
import
Flutter
class
ViewController
UIViewController
override
func
viewDidLoad
()
super
viewDidLoad
()
// Make a button to call the showFlutter function when pressed.
let
button
UIButton
type
UIButton
ButtonType
custom
button
addTarget
self
action
#selector(
showFlutter
for
touchUpInside
button
setTitle
"Show Flutter!"
for | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-12 | setTitle
"Show Flutter!"
for
UIControl
State
normal
button
frame
CGRect
80.0
210.0
width
160.0
height
40.0
button
backgroundColor
UIColor
blue
self
view
addSubview
button
@objc
func
showFlutter
()
let
flutterEngine
UIApplication
shared
delegate
as!
AppDelegate
flutterEngine
let | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-13 | AppDelegate
flutterEngine
let
flutterViewController
FlutterViewController
engine
flutterEngine
nibName
nil
bundle
nil
present
flutterViewController
animated
true
completion
nil
FlutterViewController.
The
@import
Flutter
#import "AppDelegate.h"
#import "ViewController.h"
@implementation
ViewController
void
viewDidLoad
super
viewDidLoad
];
// Make a button to call the showFlutter function when pressed.
UIButton
button
UIButton
buttonWithType | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-14 | button
UIButton
buttonWithType
UIButtonTypeCustom
];
button
addTarget
self
action:
@selector
showFlutter
forControlEvents:
UIControlEventTouchUpInside
];
button
setTitle
@"Show Flutter!"
forState
UIControlStateNormal
];
button
backgroundColor
UIColor
blueColor
button
frame
CGRectMake
80
210
160
40
);
self
view
addSubview | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-15 | self
view
addSubview
button
];
void
showFlutter
FlutterEngine
flutterEngine
((
AppDelegate
UIApplication
sharedApplication
delegate
).
flutterEngine
FlutterViewController
flutterViewController
[[
FlutterViewController
alloc
initWithEngine
flutterEngine
nibName
nil
bundle
nil
];
self
presentViewController
flutterViewController
animated
YES
completion
nil
];
@end | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-16 | nil
];
@end
Now, you have a Flutter screen embedded in your iOS app.
Alternatively - Create a FlutterViewController with an implicit FlutterEngine
As an alternative to the previous example, you can let the
FlutterViewController implicitly create its own FlutterEngine without
pre-warming one ahead of time.
This is not usually recommended because creating a
FlutterEngine on-demand could introduce a noticeable
latency between when the FlutterViewController is
presented and when it renders its first frame. This could, however, be
useful if the Flutter screen is rarely shown, when there are no good
heuristics to determine when the Dart VM should be started, and when Flutter
doesn’t need to persist state between view controllers.
To let the FlutterViewController present without an existing
FlutterEngine, omit the FlutterEngine construction, and create the
FlutterViewController without an engine reference.
SwiftUI | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-17 | SwiftUI
UIKit-Swift
UIKit-ObjC
import
SwiftUI
import
Flutter
struct
ContentView
View
var
body
some
View
Button
"Show Flutter!"
openFlutterApp
()
func
openFlutterApp
()
// Get the RootViewController.
guard
let
windowScene
UIApplication
shared
connectedScenes
first
where
$0
activationState
==
foregroundActive
&&
$0 | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-18 | foregroundActive
&&
$0
is
UIWindowScene
})
as?
UIWindowScene
let
window
windowScene
windows
first
where
isKeyWindow
),
let
rootViewController
window
rootViewController
else
return
// Create the FlutterViewController without an existing FlutterEngine.
let
flutterViewController
FlutterViewController
project
nil
nibName
nil
bundle
nil
flutterViewController
modalPresentationStyle
overCurrentContext
flutterViewController | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-19 | modalPresentationStyle
overCurrentContext
flutterViewController
isViewOpaque
false
rootViewController
present
flutterViewController
animated
true
// Existing code omitted.
func
showFlutter
()
let
flutterViewController
FlutterViewController
project
nil
nibName
nil
bundle
nil
present
flutterViewController
animated
true
completion
nil
// Existing code omitted.
void
showFlutter
FlutterViewController
flutterViewController
[[
FlutterViewController | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-20 | flutterViewController
[[
FlutterViewController
alloc
initWithProject
nil
nibName
nil
bundle
nil
];
self
presentViewController
flutterViewController
animated
YES
completion
nil
];
@end
See Loading sequence and performance
for more explorations on latency and memory usage.
Using the FlutterAppDelegate
Letting your application’s UIApplicationDelegate subclass
FlutterAppDelegate is recommended but not required.
The FlutterAppDelegate performs functions such as:
Forwarding application callbacks such as openURL
to plugins such as local_auth.
Keeping the Flutter connection open
in debug mode when the phone screen locks. | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-21 | Keeping the Flutter connection open
in debug mode when the phone screen locks.
Creating a FlutterAppDelegate subclass
Creating a subclass of the the FlutterAppDelegate in UIKit apps was shown
in the Start a FlutterEngine and FlutterViewController section.
In a SwiftUI app, you can create a subclass of the
FlutterAppDelegate that conforms to the ObservableObject protocol as follows:
import
SwiftUI
import
Flutter
import
FlutterPluginRegistrant
class
AppDelegate
FlutterAppDelegate
ObservableObject
let
flutterEngine
FlutterEngine
name
"my flutter engine"
override
func
application
application
UIApplication | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-22 | application
application
UIApplication
didFinishLaunchingWithOptions
launchOptions
UIApplication
LaunchOptionsKey
Any
]?)
>
Bool
// Runs the default Dart entrypoint with a default Flutter route.
flutterEngine
run
();
// Used to connect plugins (only if you have plugins with iOS platform code).
GeneratedPluginRegistrant
register
with
self
flutterEngine
);
return
true
@main
struct
MyApp
App
// Use this property wrapper to tell SwiftUI
// it should use the AppDelegate class for the application delegate | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-23 | // it should use the AppDelegate class for the application delegate
@UIApplicationDelegateAdaptor
AppDelegate
self
var
appDelegate
var
body
some
Scene
WindowGroup
ContentView
()
Then, in your view, the AppDelegateis accessible as an EnvironmentObject.
import
SwiftUI
import
Flutter
struct
ContentView
View
// Access the AppDelegate using an EnvironmentObject.
@EnvironmentObject
var
appDelegate
AppDelegate
var
body
some
View
Button
"Show Flutter!" | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-24 | View
Button
"Show Flutter!"
openFlutterApp
()
func
openFlutterApp
()
// Get the RootViewController.
guard
let
windowScene
UIApplication
shared
connectedScenes
first
where
$0
activationState
==
foregroundActive
&&
$0
is
UIWindowScene
})
as?
UIWindowScene
let
window
windowScene
windows
first
where
isKeyWindow
),
let | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-25 | isKeyWindow
),
let
rootViewController
window
rootViewController
else
return
// Create the FlutterViewController.
let
flutterViewController
FlutterViewController
// Access the Flutter Engine via AppDelegate.
engine
appDelegate
flutterEngine
nibName
nil
bundle
nil
flutterViewController
modalPresentationStyle
overCurrentContext
flutterViewController
isViewOpaque
false
rootViewController
present
flutterViewController
animated
true
If you can’t directly make FlutterAppDelegate a subclass | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-26 | true
If you can’t directly make FlutterAppDelegate a subclass
If your app delegate can’t directly make FlutterAppDelegate a subclass,
make your app delegate implement the FlutterAppLifeCycleProvider
protocol in order to make sure your plugins receive the necessary callbacks.
Otherwise, plugins that depend on these events may have undefined behavior.
For instance:
Swift
Objective-C
import
Foundation
import
Flutter
class
AppDelegate
UIResponder
UIApplicationDelegate
FlutterAppLifeCycleProvider
ObservableObject
private
let
lifecycleDelegate
FlutterPluginAppLifeCycleDelegate
()
let
flutterEngine
FlutterEngine
name | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-27 | flutterEngine
FlutterEngine
name
"flutter_nps_engine"
override
func
application
application
UIApplication
didFinishLaunchingWithOptions
launchOptions
UIApplication
LaunchOptionsKey
Any
]?
nil
>
Bool
func
application
application
UIApplication
didFinishLaunchingWithOptions
launchOptions
UIApplication
LaunchOptionsKey
Any
]?
nil
>
Bool
flutterEngine
run
()
return | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-28 | run
()
return
lifecycleDelegate
application
application
didFinishLaunchingWithOptions
launchOptions
??
[:])
func
application
application
UIApplication
didRegisterForRemoteNotificationsWithDeviceToken
deviceToken
Data
lifecycleDelegate
application
application
didRegisterForRemoteNotificationsWithDeviceToken
deviceToken
func
application
application
UIApplication
didFailToRegisterForRemoteNotificationsWithError
error
Error
lifecycleDelegate
application
application
didFailToRegisterForRemoteNotificationsWithError | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-29 | application
didFailToRegisterForRemoteNotificationsWithError
error
func
application
application
UIApplication
didReceiveRemoteNotification
userInfo
AnyHashable
Any
],
fetchCompletionHandler
completionHandler
@escaping
UIBackgroundFetchResult
>
Void
lifecycleDelegate
application
application
didReceiveRemoteNotification
userInfo
fetchCompletionHandler
completionHandler
func
application
app
UIApplication
open
url
URL
options
UIApplication
OpenURLOptionsKey | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-30 | options
UIApplication
OpenURLOptionsKey
Any
[:])
>
Bool
return
lifecycleDelegate
application
app
open
url
options
options
func
application
application
UIApplication
handleOpen
url
URL
>
Bool
return
lifecycleDelegate
application
application
handleOpen
url
func
application
application
UIApplication
open
url
URL
sourceApplication
String | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-31 | URL
sourceApplication
String
?,
annotation
Any
>
Bool
return
lifecycleDelegate
application
application
open
url
sourceApplication
sourceApplication
??
""
annotation
annotation
func
application
application
UIApplication
performActionFor
shortcutItem
UIApplicationShortcutItem
completionHandler
@escaping
Bool
>
Void
lifecycleDelegate
application
application
performActionFor
shortcutItem
completionHandler | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-32 | performActionFor
shortcutItem
completionHandler
completionHandler
func
application
application
UIApplication
handleEventsForBackgroundURLSession
identifier
String
completionHandler
@escaping
()
>
Void
lifecycleDelegate
application
application
handleEventsForBackgroundURLSession
identifier
completionHandler
completionHandler
func
application
application
UIApplication
performFetchWithCompletionHandler
completionHandler
@escaping
UIBackgroundFetchResult
>
Void
lifecycleDelegate
application
application | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-33 | lifecycleDelegate
application
application
performFetchWithCompletionHandler
completionHandler
func
add
delegate
FlutterApplicationLifeCycleDelegate
lifecycleDelegate
add
delegate
@import
Flutter
@import
UIKit
@import
FlutterPluginRegistrant
@interface
AppDelegate
UIResponder
UIApplicationDelegate
FlutterAppLifeCycleProvider
@property
strong
nonatomic
UIWindow
window
@property
nonatomic
strong
FlutterEngine
flutterEngine
@end | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-34 | FlutterEngine
flutterEngine
@end
The implementation should delegate mostly to a
FlutterPluginAppLifeCycleDelegate:
@interface
AppDelegate
()
@property
nonatomic
strong
FlutterPluginAppLifeCycleDelegate
lifeCycleDelegate
@end
@implementation
AppDelegate
instancetype
init
if
self
super
init
])
_lifeCycleDelegate
[[
FlutterPluginAppLifeCycleDelegate
alloc
init
];
return
self
BOOL
application
:( | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-35 | BOOL
application
:(
UIApplication
application
didFinishLaunchingWithOptions
:(
NSDictionary
UIApplicationLaunchOptionsKey
id
>*
))
launchOptions
self
flutterEngine
[[
FlutterEngine
alloc
initWithName
@"io.flutter"
project
nil
];
self
flutterEngine
runWithEntrypoint
nil
];
GeneratedPluginRegistrant
registerWithRegistry
self
flutterEngine
];
return
_lifeCycleDelegate | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-36 | ];
return
_lifeCycleDelegate
application
application
didFinishLaunchingWithOptions
launchOptions
];
// Returns the key window's rootViewController, if it's a FlutterViewController.
// Otherwise, returns nil.
FlutterViewController
rootFlutterViewController
UIViewController
viewController
UIApplication
sharedApplication
].
keyWindow
rootViewController
if
([
viewController
isKindOfClass
:[
FlutterViewController
class
]])
return
FlutterViewController
viewController
return
nil | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-37 | viewController
return
nil
void
application
:(
UIApplication
application
didRegisterUserNotificationSettings
:(
UIUserNotificationSettings
notificationSettings
_lifeCycleDelegate
application
application
didRegisterUserNotificationSettings:
notificationSettings
];
void
application
:(
UIApplication
application
didRegisterForRemoteNotificationsWithDeviceToken
:(
NSData
deviceToken
_lifeCycleDelegate
application
application
didRegisterForRemoteNotificationsWithDeviceToken:
deviceToken
];
void | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-38 | deviceToken
];
void
application
:(
UIApplication
application
didReceiveRemoteNotification
:(
NSDictionary
userInfo
fetchCompletionHandler
:(
void
)(
UIBackgroundFetchResult
result
))
completionHandler
_lifeCycleDelegate
application
application
didReceiveRemoteNotification:
userInfo
fetchCompletionHandler:
completionHandler
];
BOOL
application
:(
UIApplication
application
openURL
:(
NSURL
url
options | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-39 | NSURL
url
options
:(
NSDictionary
UIApplicationOpenURLOptionsKey
id
>*
options
return
_lifeCycleDelegate
application
application
openURL
url
options
options
];
BOOL
application
:(
UIApplication
application
handleOpenURL
:(
NSURL
url
return
_lifeCycleDelegate
application
application
handleOpenURL
url
];
BOOL
application
:(
UIApplication | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-40 | application
:(
UIApplication
application
openURL
:(
NSURL
url
sourceApplication
:(
NSString
sourceApplication
annotation
:(
id
annotation
return
_lifeCycleDelegate
application
application
openURL:
url
sourceApplication:
sourceApplication
annotation:
annotation
];
void
application
:(
UIApplication
application
performActionForShortcutItem
:(
UIApplicationShortcutItem
shortcutItem
completionHandler | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-41 | UIApplicationShortcutItem
shortcutItem
completionHandler
:(
void
)(
BOOL
succeeded
))
completionHandler
_lifeCycleDelegate
application
application
performActionForShortcutItem:
shortcutItem
completionHandler:
completionHandler
];
void
application
:(
UIApplication
application
handleEventsForBackgroundURLSession
:(
nonnull
NSString
identifier
completionHandler
:(
nonnull
void
)(
void
))
completionHandler | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-42 | void
))
completionHandler
_lifeCycleDelegate
application
application
handleEventsForBackgroundURLSession:
identifier
completionHandler:
completionHandler
];
void
application
:(
UIApplication
application
performFetchWithCompletionHandler
:(
void
)(
UIBackgroundFetchResult
result
))
completionHandler
_lifeCycleDelegate
application
application
performFetchWithCompletionHandler
completionHandler
];
void
addApplicationLifeCycleDelegate
:(
NSObject
FlutterPlugin | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-43 | :(
NSObject
FlutterPlugin
>*
delegate
_lifeCycleDelegate
addDelegate
delegate
];
@end
Launch options
The examples demonstrate running Flutter using the default launch settings.
In order to customize your Flutter runtime,
you can also specify the Dart entrypoint, library, and route.
Dart entrypoint
Calling run on a FlutterEngine, by default,
runs the main() Dart function
of your lib/main.dart file.
You can also run a different entrypoint function by using
runWithEntrypoint with an NSString specifying
a different Dart function.
Note:
Dart entrypoint functions other than main()
must be annotated with the following in order to
not be tree-shaken away when compiling:
@pragma | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-44 | @pragma
'vm:entry-point'
void
myOtherEntrypoint
()
...
};
Dart library
In addition to specifying a Dart function, you can specify an entrypoint
function in a specific file.
For instance the following runs myOtherEntrypoint()
in lib/other_file.dart instead of main() in lib/main.dart:
Swift
Objective-C
flutterEngine
run
withEntrypoint
"myOtherEntrypoint"
libraryURI
"other_file.dart"
flutterEngine
runWithEntrypoint
@"myOtherEntrypoint"
libraryURI
@"other_file.dart"
];
Route | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-45 | @"other_file.dart"
];
Route
Starting in Flutter version 1.22, an initial route can be set for your Flutter
WidgetsApp when constructing the FlutterEngine or the
FlutterViewController.
Swift
Objective-C
let
flutterEngine
FlutterEngine
()
// FlutterDefaultDartEntrypoint is the same as nil, which will run main().
engine
run
withEntrypoint
FlutterDefaultDartEntrypoint
initialRoute
"/onboarding"
FlutterEngine
flutterEngine
[[
FlutterEngine
alloc
init
];
// FlutterDefaultDartEntrypoint is the same as nil, which will run main(). | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-46 | // FlutterDefaultDartEntrypoint is the same as nil, which will run main().
flutterEngine
runWithEntrypoint
FlutterDefaultDartEntrypoint
initialRoute:
@"/onboarding"
];
This code sets your dart:ui’s window.defaultRouteName
to "/onboarding" instead of "/".
Alternatively, to construct a FlutterViewController directly without pre-warming
a FlutterEngine:
Swift
Objective-C
let
flutterViewController
FlutterViewController
project
nil
initialRoute
"/onboarding"
nibName
nil
bundle
nil
FlutterViewController
flutterViewController
[[
FlutterViewController | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
dfaec9f3ec15-47 | flutterViewController
[[
FlutterViewController
alloc
initWithProject
nil
initialRoute:
@"/onboarding"
nibName:
nil
bundle:
nil
];
pushRoute()
or
popRoute() on the
To pop the iOS route from the Flutter side,
call SystemNavigator.pop().
See Navigation and routing for more about Flutter’s routes.
Other
The previous example only illustrates a few ways to customize
how a Flutter instance is initiated. Using platform channels,
you’re free to push data or prepare your Flutter environment
in any way you’d like, before presenting the Flutter UI using a
FlutterViewController. | https://docs.flutter.dev/development/add-to-app/ios/add-flutter-screen/index.html |
2b6af13db0bd-0 | Adding Flutter to iOS
Add Flutter to existing app
Adding Flutter to iOS
Topics:
Project setup
Add a single Flutter screen | https://docs.flutter.dev/development/add-to-app/ios/index.html |
6d072c206700-0 | Integrate a Flutter module into your iOS project
Add Flutter to existing app
Adding Flutter to iOS
Integrate Flutter
System requirements
Create a Flutter module
Module organization
Embed the Flutter module in your existing application
Option A - Embed with CocoaPods and the Flutter SDK
Option B - Embed frameworks in Xcode
Link on the frameworks
Embed the frameworks
Option C - Embed application and plugin frameworks in Xcode and Flutter framework with CocoaPods
Local Network Privacy Permissions
Apple Silicon (arm64 Macs)
Development
Flutter UI components can be incrementally added into your existing iOS
application as embedded frameworks. There are a few ways to embed Flutter
in your existing application. | https://docs.flutter.dev/development/add-to-app/ios/project-setup/index.html |
6d072c206700-1 | Use the CocoaPods dependency manager and installed Flutter SDK.
In this case, the flutter_module is compiled from
the source each time the app is built. (Recommended.)
Create frameworks for the Flutter engine, your compiled Dart code,
and all Flutter plugins. Here, you manually embed the frameworks,
and update your existing application’s build settings in Xcode.
This can be useful for teams that don’t want to require every developer
to have the Flutter SDK and Cocoapods installed locally.
Create frameworks for your compiled Dart code,
and all Flutter plugins. Use CocoaPods for the Flutter engine.
With this option, embed the frameworks for your application
and the plugins in Xcode, but distribute the
Flutter engine as a CocoaPods podspec.
This is similar to the second option, but it provides
an alternative to distributing the large Flutter.xcframework. | https://docs.flutter.dev/development/add-to-app/ios/project-setup/index.html |
6d072c206700-2 | For examples using an app built with UIKit,
see the iOS directories in the add_to_app code samples.
For an example using SwiftUI, see the iOS directory in News Feed App.
System requirements
Your development environment must meet the
macOS system requirements for Flutter
with Xcode installed.
Flutter supports iOS 11 and later.
Additionally, you will need CocoaPods
version 1.10 or later.
Create a Flutter module
To embed Flutter into your existing application,
using any of the methods mentioned above,
first create a Flutter module.
From the command line, run:
cd some/path/
flutter create --template module my_flutter
A Flutter module project is created at some/path/my_flutter/.
If you are using the first method mentioned above,
the module should be created in the same parent directory
as your existing iOS app. | https://docs.flutter.dev/development/add-to-app/ios/project-setup/index.html |
6d072c206700-3 | From the Flutter module directory, you can run the same flutter
commands you would in any other Flutter project,
like flutter run --debug or flutter build ios.
You can also run the module in
Android Studio/IntelliJ or VS Code with
the Flutter and Dart plugins. This project contains a
single-view example version of your module before it’s
embedded in your existing application,
which is useful for incrementally
testing the Flutter-only parts of your code.
Module organization
The my_flutter module directory structure is similar to a
normal Flutter application:
Add your Dart code to the lib/ directory.
Add Flutter dependencies to my_flutter/pubspec.yaml,
including Flutter packages and plugins.
The .ios/ hidden subfolder contains an Xcode workspace where
you can run a standalone version of your module.
It is a wrapper project to bootstrap your Flutter code,
and contains helper scripts to facilitate building frameworks or
embedding the module into your existing application with CocoaPods. | https://docs.flutter.dev/development/add-to-app/ios/project-setup/index.html |
6d072c206700-4 | Note:
Add custom iOS code to your own existing application’s
project or to a plugin, not to the module’s .ios/
directory. Changes made in your module’s .ios/
directory do not appear in your existing iOS project
using the module, and may be overwritten by Flutter.
Do not source control the .ios/ directory since it’s autogenerated.
Before building the module on a new machine, run flutter pub get
in the my_flutter directory first to regenerate the .ios/
directory before building iOS project using the Flutter module.
Embed the Flutter module in your existing application
After you have developed your Flutter module,
you can embed it using the methods described at the top of the page.
Note:
You can run in Debug mode on a simulator or a real device,
and Release on a real device. Learn more about
Flutter’s build modes | https://docs.flutter.dev/development/add-to-app/ios/project-setup/index.html |
6d072c206700-5 | To leverage Flutter debugging functionality
such as hot reload, see Debugging your add-to-app module.
Using Flutter increases your app size.
Option A - Embed with CocoaPods and the Flutter SDK
This method requires every developer working on your
project to have a locally installed version of the Flutter SDK.
The Flutter module is compiled from source each time the app is built.
Simply build your application in Xcode to automatically
run the script to embed your Dart and plugin code.
This allows rapid iteration with the most up-to-date
version of your Flutter module without running additional
commands outside of Xcode.
The following example assumes that your existing
application and the Flutter module are in sibling
directories. If you have a different directory structure,
you may need to adjust the relative paths. | https://docs.flutter.dev/development/add-to-app/ios/project-setup/index.html |
6d072c206700-6 | If your existing application (MyApp) doesn’t
already have a Podfile, run pod init in the
MyApp directory to create one.
You can find more details on using
CocoaPods in the CocoaPods getting started guide.
Add the following lines to your Podfile:
flutter_application_path = '../my_flutter'
load File.join(flutter_application_path, '.ios', 'Flutter', 'podhelper.rb')
For each Podfile target that needs to
embed Flutter, call install_all_flutter_pods(flutter_application_path).
target 'MyApp' do
install_all_flutter_pods(flutter_application_path)
end
In the Podfile’s post_install block, call flutter_post_install(installer). | https://docs.flutter.dev/development/add-to-app/ios/project-setup/index.html |
6d072c206700-7 | post_install do |installer|
flutter_post_install(installer) if defined?(flutter_post_install)
end
Note:
The flutter_post_install method (added in Flutter 3.1.0),
adds build settings to support native Apple Silicon arm64 iOS simulators.
Include the if defined?(flutter_post_install) check to ensure your Podfile
is valid if you are running on older versions of Flutter that don’t have this method.
Run pod install.
Note:
When you change the Flutter plugin dependencies in
my_flutter/pubspec.yaml, run flutter pub get
in your Flutter module directory to refresh the list
of plugins read by the podhelper.rb script.
Then, run pod install again from
your application at some/path/MyApp.
The podhelper.rb script embeds your plugins,
Flutter.framework, and App.framework into your project. | https://docs.flutter.dev/development/add-to-app/ios/project-setup/index.html |
6d072c206700-8 | Your app’s Debug and Release build configurations embed
the Debug or Release build modes of Flutter, respectively.
Add a Profile build configuration
to your app to test in profile mode.
Tip:
Flutter.framework is the bundle for the Flutter engine,
and App.framework is the compiled Dart code for this project.
Open MyApp.xcworkspace in Xcode.
You can now build the project using ⌘B.
Option B - Embed frameworks in Xcode
Alternatively, you can generate the necessary frameworks
and embed them in your application by manually editing
your existing Xcode project. You may do this if members of your
team can’t locally install Flutter SDK and CocoaPods,
or if you don’t want to use CocoaPods
as a dependency manager in your existing applications.
You must run flutter build ios-framework
every time you make code changes in your Flutter module.
The following example assumes that you want to generate the
frameworks to some/path/MyApp/Flutter/. | https://docs.flutter.dev/development/add-to-app/ios/project-setup/index.html |
6d072c206700-9 | flutter build ios-framework --output=some/path/MyApp/Flutter/
Link and embed the generated frameworks into your existing
application in Xcode. There are multiple ways to do
this—use the method that is best for your project.
Link on the frameworks
For example, you can drag the frameworks from
some/path/MyApp/Flutter/Release/ in Finder
into your target’s Build
Settings > Build Phases > Link Binary With Libraries.
In the target’s build settings, add $(PROJECT_DIR)/Flutter/Release/
to the Framework Search Paths (FRAMEWORK_SEARCH_PATHS). | https://docs.flutter.dev/development/add-to-app/ios/project-setup/index.html |
6d072c206700-10 | Tip:
To use the simulator, you will need to
embed the Debug version of the Flutter frameworks in your
Debug build configuration. To do this
you can use $(PROJECT_DIR)/Flutter/$(CONFIGURATION)
in the Framework Search Paths (FRAMEWORK_SEARCH_PATHS)
build setting. This embeds the Release frameworks in the Release configuration,
and the Debug frameworks in the Debug Configuration.
You must also open MyApp.xcodeproj/project.pbxproj (from Finder)
and replace path = Flutter/Release/example.xcframework;
with path = "Flutter/$(CONFIGURATION)/example.xcframework";
for all added frameworks. (Note the added ".)
Embed the frameworks
The generated dynamic frameworks must be embedded
into your app to be loaded at runtime. | https://docs.flutter.dev/development/add-to-app/ios/project-setup/index.html |
6d072c206700-11 | The generated dynamic frameworks must be embedded
into your app to be loaded at runtime.
Important:
Plugins might produce static or dynamic frameworks.
Static frameworks should be linked on, but never embedded.
If you embed a static framework into your application,
your application is not publishable to the App Store
and fails with a
Found an unexpected Mach-O header code archive error.
After linking the frameworks, you should see them in the
Frameworks, Libraries, and Embedded Content
section of your target’s General settings.
To embed the dynamic frameworks
select Embed & Sign.
They will then appear under Embed Frameworks within
Build Phases as follows:
You should now be able to build the project in Xcode using ⌘B.
Option C - Embed application and plugin frameworks in Xcode and Flutter framework with CocoaPods | https://docs.flutter.dev/development/add-to-app/ios/project-setup/index.html |
6d072c206700-12 | Alternatively, instead of distributing the large Flutter.xcframework
to other developers, machines, or continuous integration systems,
you can instead generate Flutter as CocoaPods podspec by adding
the flag --cocoapods. This produces a Flutter.podspec
instead of an engine Flutter.xcframework.
The App.xcframework and plugin frameworks are generated
as described in Option B.
To generate the Flutter.podspec and frameworks, run the following
from the command line in the root of your Flutter module:
flutter build ios-framework --cocoapods --output=some/path/MyApp/Flutter/
Host apps using CocoaPods can add Flutter to their Podfile:
pod
'Flutter'
:podspec
=>
'some/path/MyApp/Flutter/[build mode]/Flutter.podspec' | https://docs.flutter.dev/development/add-to-app/ios/project-setup/index.html |
6d072c206700-13 | Link and embed the generated App.xcframework,
FlutterPluginRegistrant.xcframework,
and any plugin frameworks into your existing application
as described in Option B.
Local Network Privacy Permissions
On iOS 14 and higher, enable the Dart multicast DNS
service in the Debug version of your app
to add debugging functionalities such as hot-reload and
DevTools via flutter attach.
Warning:
This service must not be enabled in the Release
version of your app, or you may experience App Store rejections.
One way to do this is to maintain a separate copy of your app’s Info.plist per
build configuration. The following instructions assume
the default Debug and Release.
Adjust the names as needed depending on your app’s build configurations.
Rename your app’s Info.plist to Info-Debug.plist.
Make a copy of it called Info-Release.plist and add it to your Xcode project. | https://docs.flutter.dev/development/add-to-app/ios/project-setup/index.html |
6d072c206700-14 | In Info-Debug.plist only add the key NSBonjourServices
and set the value to an array with the string _dartobservatory._tcp.
Note Xcode will display this as “Bonjour services”.
Optionally, add the key NSLocalNetworkUsageDescription set to your
desired customized permission dialog text.
In your target’s build settings, change the Info.plist File
(INFOPLIST_FILE) setting path from path/to/Info.plist to path/to/Info-$(CONFIGURATION).plist.
This will resolve to the path Info-Debug.plist in Debug and
Info-Release.plist in Release.
Alternatively, you can explicitly set the Debug path to Info-Debug.plist
and the Release path to Info-Release.plist. | https://docs.flutter.dev/development/add-to-app/ios/project-setup/index.html |
6d072c206700-15 | If the Info-Release.plist copy is in your target’s Build Settings > Build Phases > Copy Bundle
Resources build phase, remove it.
The first Flutter screen loaded by your Debug app will now prompt
for local network permission. The permission can also be allowed by enabling
Settings > Privacy > Local Network > Your App.
Apple Silicon (arm64 Macs)
On an Apple Silicon (M1) Mac, the host app builds for an arm64 simulator.
While Flutter supports arm64 simulators, some plugins might not. If you use
one of these plugins, you might see a compilation error like Undefined symbols
for architecture arm64 and you must exclude arm64 from the simulator
architectures in your host app.
When done correctly, Xcode will add "EXCLUDED_ARCHS[sdk=iphonesimulator*]" = arm64; to your project.pbxproj file. | https://docs.flutter.dev/development/add-to-app/ios/project-setup/index.html |
6d072c206700-16 | Repeat for any iOS unit test targets.
Development
You can now add a Flutter screen to your existing application. | https://docs.flutter.dev/development/add-to-app/ios/project-setup/index.html |
49d5b08a8f8a-0 | Multiple Flutter screens or views
Add Flutter to existing app
Adding multiple Flutters
Scenarios
Components
Communication
Samples
Scenarios
If you’re integrating Flutter into an existing app, or gradually migrating an
existing app to use Flutter, you may find yourself wanting to add multiple
Flutter instances to the same project. In particular, this can be useful in the
following scenarios:
An application where the integrated Flutter screen is not a leaf node of
the navigation graph, and the navigation stack might be a hybrid mixture of
native -> Flutter -> native -> Flutter.
A screen where multiple partial screen Flutter views might be integrated
and visible at once. | https://docs.flutter.dev/development/add-to-app/multiple-flutters/index.html |
49d5b08a8f8a-1 | A screen where multiple partial screen Flutter views might be integrated
and visible at once.
The advantage of using multiple Flutter instances is that each
instance is independent and maintains its own internal navigation
stack, UI, and application states. This simplifies the overall application code’s
responsibility for state keeping and improves modularity. More details on the
scenarios motivating the usage of multiple Flutters can be found at
docs.flutter.dev/go/multiple-flutters.
Flutter 2 and above are optimized for this scenario, with a low incremental
memory cost (~180kB) for adding additional Flutter instances. This fixed cost
reduction allows the multiple Flutter instance pattern to be used more liberally
in your add-to-app integration.
Components
The primary API for adding multiple Flutter instances on both Android and iOS
is based on a new FlutterEngineGroup class (Android API, iOS API)
to construct FlutterEngines, rather than the FlutterEngine
constructors used previously. | https://docs.flutter.dev/development/add-to-app/multiple-flutters/index.html |
49d5b08a8f8a-2 | Whereas the FlutterEngine API was direct and easier to consume, the
FlutterEngine spawned from the same FlutterEngineGroup have the performance
advantage of sharing many of the common, reusable resources such as the GPU
context, font metrics, and isolate group snapshot, leading to a faster initial
rendering latency and lower memory footprint.
FlutterEngines spawned from FlutterEngineGroup can be used to
connect to UI classes like FlutterActivity or FlutterViewController
in the same way as normally constructed cached FlutterEngines.
The first FlutterEngine spawned from the FlutterEngineGroup doesn’t need
to continue surviving in order for subsequent FlutterEngines to share
resources as long as there’s at least 1 living FlutterEngine at all
times.
Creating the very first FlutterEngine from a FlutterEngineGroup has
the same performance characteristics as constructing a
FlutterEngine using the constructors did previously. | https://docs.flutter.dev/development/add-to-app/multiple-flutters/index.html |
49d5b08a8f8a-3 | When all FlutterEngines from a FlutterEngineGroup are destroyed, the next
FlutterEngine created has the same performance characteristics as the very
first engine.
The FlutterEngineGroup itself doesn’t need to live beyond all of the spawned
engines. Destroying the FlutterEngineGroup doesn’t affect existing spawned
FlutterEngines but does remove the ability to spawn additional
FlutterEngines that share resources with existing spawned engines.
Communication
Communication between Flutter instances is handled using platform channels
(or Pigeon) through the host platform. To see our roadmap on communication,
or other planned work on enhancing multiple Flutter instances, see
Issue 72009.
Samples
You can find a sample demonstrating how to use FlutterEngineGroup
on both Android and iOS on GitHub. | https://docs.flutter.dev/development/add-to-app/multiple-flutters/index.html |
2bea1c7e0ba4-0 | Load sequence, performance, and memory
Add Flutter to existing app
Load sequence, performance, and memory
Loading Flutter
Finding the Flutter resources
Loading the Flutter library
Starting the Dart VM
Creating and running a Dart Isolate
Attaching a UI to the Flutter engine
Memory and latency
This page describes the breakdown of the steps involved
to show a Flutter UI. Knowing this, you can make better,
more informed decisions about when to pre-warm the Flutter engine,
which operations are possible at which stage,
and the latency and memory costs of those operations.
Loading Flutter
Android and iOS apps (the two supported platforms for
integrating into existing apps), full Flutter apps,
and add-to-app patterns have a similar sequence of
conceptual loading steps when displaying the Flutter UI.
Finding the Flutter resources | https://docs.flutter.dev/development/add-to-app/performance/index.html |
2bea1c7e0ba4-1 | Finding the Flutter resources
Flutter’s engine runtime and your application’s compiled
Dart code are both bundled as shared libraries on Android
and iOS. The first step of loading Flutter is to find those
resources in your .apk/.ipa/.app (along with other Flutter
assets such as images, fonts, and JIT code, if applicable).
This happens when you construct a FlutterEngine for the
first time on both Android
and iOS APIs.
Loading the Flutter library
After it’s found, the engine’s shared libraries are memory loaded
once per process.
On Android, this also happens when the
FlutterEngine is constructed because the
JNI connectors need to reference the Flutter C++ library.
On iOS, this happens when the
FlutterEngine is first run,
such as by running runWithEntrypoint:.
Starting the Dart VM | https://docs.flutter.dev/development/add-to-app/performance/index.html |
2bea1c7e0ba4-2 | Starting the Dart VM
The Dart runtime is responsible for managing Dart memory and
concurrency for your Dart code. In JIT mode,
it’s additionally responsible for compiling
the Dart source code into machine code during runtime.
A single Dart runtime exists per application session on
Android and iOS.
A one-time Dart VM start is done when constructing the
FlutterEngine for the first time on
Android and when running a Dart entrypoint
for the first time on iOS.
At this point, your Dart code’s snapshot
is also loaded into memory from your application’s files.
This is a generic process that also occurs if you used the
Dart SDK directly, without the Flutter engine.
The Dart VM never shuts down after it’s started.
Creating and running a Dart Isolate
After the Dart runtime is initialized,
the Flutter engine’s usage of the Dart
runtime is the next step. | https://docs.flutter.dev/development/add-to-app/performance/index.html |
2bea1c7e0ba4-3 | This is done by starting a Dart Isolate in the Dart runtime.
The isolate is Dart’s container for memory and threads.
A number of auxiliary threads on the host platform are
also created at this point to support the isolate, such
as a thread for offloading GPU handling and another for image decoding.
One isolate exists per FlutterEngine instance, and multiple isolates
can be hosted by the same Dart VM.
On Android, this happens when you call
DartExecutor.executeDartEntrypoint()
on a FlutterEngine instance.
On iOS, this happens when you call runWithEntrypoint:
on a FlutterEngine.
runApp() in your
Attaching a UI to the Flutter engine
A standard, full Flutter app moves to reach this state as
soon as the app is launched.
startActivity()
with an
Intent built using
FlutterActivity.withCachedEngine()
on | https://docs.flutter.dev/development/add-to-app/performance/index.html |
2bea1c7e0ba4-4 | Intent built using
FlutterActivity.withCachedEngine()
on
FlutterViewController
initialized by using
initWithEngine: nibName: bundle:
on
FlutterActivity.createDefaultIntent() on
FlutterViewController initWithProject: nibName: bundle:
on
Surface on
CAEAGLLayer or
CAMetalLayer
on
At this point, the Layer tree generated by your Flutter
program, per frame, is converted into
OpenGL (or Vulkan or Metal) GPU instructions.
Memory and latency
Showing a Flutter UI has a non-trivial latency cost.
This cost can be lessened by starting the Flutter engine
ahead of time. | https://docs.flutter.dev/development/add-to-app/performance/index.html |
2bea1c7e0ba4-5 | The most relevant choice for add-to-app scenarios is for you
to decide when to pre-load a FlutterEngine
(that is, to load the Flutter library, start the Dart VM,
and run entrypoint in an isolate), and what the memory and latency
cost is of that pre-warm. You also need to know how the pre-warm
affects the memory and latency cost of rendering a first Flutter
frame when the UI component is subsequently attached
to that FlutterEngine.
As of Flutter v1.10.3, and testing on a low-end 2015 class device
in release-AOT mode, pre-warming the FlutterEngine costs:
42 MB and 1530 ms to prewarm on Android.
330 ms of it is a blocking call on the main thread.
22 MB and 860 ms to prewarm on iOS.
260 ms of it is a blocking call on the main thread. | https://docs.flutter.dev/development/add-to-app/performance/index.html |
2bea1c7e0ba4-6 | A Flutter UI can be attached during the pre-warm.
The remaining time is joined to the time-to-first-frame latency.
Memory-wise, a cost sample (variable,
depending on the use case) could be:
~4 MB OS’s memory usage for creating pthreads.
~10 MB GPU driver memory.
~1 MB for Dart runtime-managed memory.
~5 MB for Dart-loaded font maps.
Latency-wise,
a cost sample (variable, depending on the use case) could be:
~20 ms to collect the Flutter assets from the application package.
~15 ms to dlopen the Flutter engine library.
~200 ms to create the Dart VM and load the AOT snapshot.
~200 ms to load Flutter-dependent fonts and assets. | https://docs.flutter.dev/development/add-to-app/performance/index.html |
2bea1c7e0ba4-7 | ~200 ms to load Flutter-dependent fonts and assets.
~400 ms to run the entrypoint, create the first widget tree,
and compile the needed GPU shader programs.
The FlutterEngine should be pre-warmed late enough to delay the
memory consumption needed but early enough to avoid combining the
Flutter engine start-up time with the first frame latency of
showing Flutter.
The exact timing depends on the app’s structure and heuristics.
An example would be to load the Flutter engine in the screen
before the screen is drawn by Flutter.
Given an engine pre-warm, the first frame cost on UI attach is:
320 ms on Android and an additional 12 MB
(highly dependent on the screen’s physical pixel size).
200 ms on iOS and an additional 16 MB
(highly dependent on the screen’s physical pixel size). | https://docs.flutter.dev/development/add-to-app/performance/index.html |
2bea1c7e0ba4-8 | Memory-wise, the cost is primarily the graphical memory buffer used for
rendering and is dependent on the screen size.
Latency-wise, the cost is primarily waiting for the OS callback to provide
Flutter with a rendering surface and compiling the remaining shader programs
that are not pre-emptively predictable. This is a one-time cost.
When the Flutter UI component is released, the UI-related memory is freed.
This doesn’t affect the Flutter state, which lives in the FlutterEngine
(unless the FlutterEngine is also released).
For performance details on creating more than one FlutterEngine,
see multiple Flutters. | https://docs.flutter.dev/development/add-to-app/performance/index.html |
ea4e098982d7-0 | Firebase
Data & backend
Firebase
Firebase is a Backend-as-a-Service (BaaS) app development platform
that provides hosted backend services such as a realtime database,
cloud storage, authentication, crash reporting, machine learning,
remote configuration, and hosting for your static files.
Firebase supports Flutter. For more information, see:
The Firebase plugins page
Getting started with Firebase and Flutter
Get to know Firebase for Flutter video workshop
based on the codelab
Get to know Firebase for Flutter codelab
Use Firebase to host your Flutter app on the web
Also, the Flutter community has created docs and
videos that you might find useful. Here are a few:
Building chat app with Flutter and Firebase
Using Firestore as a backend to your Flutter app (video)
Live Coding Firebase Authentication with Flutter (video) | https://docs.flutter.dev/development/data-and-backend/firebase/index.html |
ea4e098982d7-1 | Live Coding Firebase Authentication with Flutter (video)
Flutter & Firebase Auth 01 (video)
Flutter: Firebase Tutorial Part 1 - Auth and Sign in (video) | https://docs.flutter.dev/development/data-and-backend/firebase/index.html |
f4af05977518-0 | Google APIs
Data & backend
Google APIs
Overview
1. Pick the desired API
2. Enable the API
3. Authenticate the user with the required scopes
4. Obtain an authenticated HTTP client
5. Create and use the desired API class
More information
The Google APIs package exposes dozens of Google
services that you can use from Dart projects.
This page describes how to use APIs that interact with end-user data by using
Google authentication.
Examples of user-data APIs include
Calendar,
Gmail, and
YouTube.
Note: The only APIs you should use directly from your Flutter
project are those that access user data via Google authentication. | https://docs.flutter.dev/development/data-and-backend/google-apis/index.html |
f4af05977518-1 | APIs that require
service accounts should
not be used directly from a Flutter application. Doing so requires shipping
service credentials as part of your application, which is not secure. To use
these APIs, we recommend creating an intermediate service.
Overview
To use Google APIs, follow these steps.
Pick the desired API
Enable the API
Authenticate user with the required scopes
Obtain an authenticated HTTP client
Create and use the desired API class
1. Pick the desired API
The documentation for package:googleapis lists
each API as a separate Dart library – in a name.version format. Let’s look at
youtube.v3
as an example.
Each library may provide many types, but there is one root class that ends in
Api. For YouTube, it’s
YouTubeApi. | https://docs.flutter.dev/development/data-and-backend/google-apis/index.html |
f4af05977518-2 | Not only is the Api class the one you need to instantiate – see step 3 – but
it also exposes the scopes that represent the permissions needed to use the API.
Look under the
Constants section
of the YouTubeApi class and you’ll see the available scopes. To request access
to simply read (but not write) an end-users YouTube data, use the
youtubeReadonlyScope
when authenticating the user.
2. Enable the API
To use Google APIs you must have a Google account and a Google project. You also
need to enable your desired API.
In this example, you’d enable
YouTube Data API v3.
For details, see the
getting started instructions.
3. Authenticate the user with the required scopes
Use the google_sign_in package to
authenticate users with their Google identity. You will have to configure signin
for each platform you want to support. | https://docs.flutter.dev/development/data-and-backend/google-apis/index.html |
f4af05977518-3 | When you instantiate the
GoogleSignIn
class, you provide the desired scopes as discussed in the previous section.
Follow the instructions provided by
package:google_sign_in to allow a user to
authenticate.
Once authenticated, you must obtain an authenticated HTTP client.
4. Obtain an authenticated HTTP client
The
extension_google_sign_in_as_googleapis_auth
package provides an
extension method on
GoogleSignIn:
authenticatedClient.
You can listen to
onCurrentUserChanged.
When event value is not null, you can create an authenticated client.
This Client instance
includes the nessesary credentials when invoking Google API classes.
5. Create and use the desired API class
Use the API to create the desired API type and call methods, for instance:
More information | https://docs.flutter.dev/development/data-and-backend/google-apis/index.html |
f4af05977518-4 | More information
The
extension_google_sign_in_as_googleapis_auth example
is a working implementation of the concepts described on this page. | https://docs.flutter.dev/development/data-and-backend/google-apis/index.html |
948500feffc0-0 | Data & backend
Data & backend
Topics:
State management
Networking & http
JSON and serialization
Firebase | https://docs.flutter.dev/development/data-and-backend/index.html |
de6d0c61b45b-0 | JSON and serialization
Data & backend
JSON and serialization
Which JSON serialization method is right for me?
Use manual serialization for smaller projects
Use code generation for medium to large projects
Is there a GSON/Jackson/Moshi equivalent in Flutter?
Serializing JSON manually using dart:convert
Serializing JSON inline
Serializing JSON inside model classes
Serializing JSON using code generation libraries
Setting up json_serializable in a project
Creating model classes the json_serializable way
Running the code generation utility
One-time code generation
Generating code continuously
Consuming json_serializable models
Generating code for nested classes
Further references | https://docs.flutter.dev/development/data-and-backend/json/index.html |
de6d0c61b45b-1 | Generating code for nested classes
Further references
It is hard to think of a mobile app that doesn’t need to communicate with a
web server or easily store structured data at some point. When making
network-connected apps, the chances are that it needs to consume some good old
JSON, sooner or later.
This guide looks into ways of using JSON with Flutter.
It covers which JSON solution to use in different scenarios, and why.
To avoid confusion, this doc uses “serialization” when referring to the
overall process, and “encoding” and “decoding” when specifically
referring to those processes.
Which JSON serialization method is right for me?
This article covers two general strategies for working with JSON:
Manual serialization
Automated serialization using code generation | https://docs.flutter.dev/development/data-and-backend/json/index.html |
Subsets and Splits