Description:

android pip

A complete Picture-In-Picture mode plugin for android API level 26+ (Android Oreo).(Based on simple_pip_mode)
Provides methods to check feature availability, enter PIP mode, callbacks for mode change and PIP Actions support.

How is this different from simple_pip_mode? #

Fixed reload of UI when switching to and from PIP.
Enabled support to disable autoPIP.
Added more PIPActions(seeking).
Differentiates between onPipMaximised(when App is opened from PIP) and onPipExited(when PIP is closed)
You can now decide whether you wish to use an IndexedStack based approach or not(default true).
Other changes(See changelog).

Features #

Verify PIP system availability and current state.
Method to enter PIP mode, with aspect ratio, auto enter and seamless resize parameters.
On PIP mode change Callbacks(onPipEntered, onPipMaximised, onPipExited).
Widget to build PIP-dependent layouts.
PIP Actions (media action presets).

Installation #
In the dependencies: section of your pubspec.yaml, add the following line:
android_pip: <latest_version>
copied to clipboard
Usage #
This section has example code for the following tasks:

Update manifest
Verify PIP support
Entering PIP mode
Enabling callbacks
Using callbacks
Using the PIP Widget
Using PIP Actions

Update manifest #
Add android:supportsPictureInPicture="true" to the activity on your AndroidManifest.xml.
Verify pip support #
Use AndroidPIP.isPipAvailable and AndroidPIP.isPipActivated static getters to verify whether the device supports Picture In Picture feature and the feature is currently activated respectively.
Entering pip mode #
Import android_pip.dart file and call enterPipMode method.
import 'package:android_pip/android_pip.dart';

class MyWidget extends StatelessWidget {
Widget build(BuildContext context) {
return IconButton(
icon: Icon(Icons.picture_in_picture),
onPressed: () => AndroidPIP().enterPipMode(),
);
}
}
copied to clipboard
Setting automatic pip mode #
Import android_pip.dart file and call setAutoPipMode method.
This needs at least API level 31.
import 'package:android_pip/android_pip.dart';

class MyWidget extends StatelessWidget {
Widget build(BuildContext context) {
return IconButton(
icon: Icon(Icons.picture_in_picture),
onPressed: () => AndroidPIP().setAutoPipMode(),
);
}
}
copied to clipboard
This way, when user presses home (or uses home gesture), the app enters PIP mode automatically.
Enabling callbacks #
There's two ways of enabling callbacks:

Activity wrapper (Recommended!)
Callback helper

Activity wrapper #
This is the easiest way to enable the callbacks.
Just import the wrapper class in your main activity file, and inherit from it.
Kotlin
import com.thesparks.android_pip.PipCallbackHelperActivityWrapper

class MainActivity: PipCallbackHelperActivityWrapper() {
}
copied to clipboard
Java
import com.thesparks.android_pip.PipCallbackHelperActivityWrapper;

class MainActivity extends PipCallbackHelperActivityWrapper {
}
copied to clipboard
Done! now you can use PIP callbacks and the PIP widget.
Callback helper #
If something went wrong with Activity wrapper or you don't want to wrap your activity,
you can enable callbacks using the callback helper.
To do so, in your main activity file import the callback helper.
import com.thesparks.android_pip.PipCallbackHelper
copied to clipboard
Instance a callback helper, provide the flutter engine to it, and finally, call helper on callback.
Kotlin
class MainActivity: FlutterActivity() {
//...
private var callbackHelper = PipCallbackHelper()
//...
override fun configureFlutterEngine(@NonNull flutterEngine: FlutterEngine) {
super.configureFlutterEngine(flutterEngine)
callbackHelper.configureFlutterEngine(flutterEngine)
}

override fun onPictureInPictureModeChanged(active: Boolean, newConfig: Configuration?) {
callbackHelper.onPictureInPictureModeChanged(active,this)
}
//...
}
copied to clipboard
Java
public class MainActivity extends FlutterActivity {
//...
private final PipCallbackHelper callbackHelper = new PipCallbackHelper();
//...
@Override
public void configureFlutterEngine(@NonNull FlutterEngine flutterEngine) {
super.configureFlutterEngine(flutterEngine);
callbackHelper.configureFlutterEngine(flutterEngine);
}

@Override
public void onPictureInPictureModeChanged(boolean active, Configuration newConfig) {
callbackHelper.onPictureInPictureModeChanged(active,MainActivity.this);
}
//...
}
copied to clipboard
Done! now you can use PIP callbacks and the PIP widget.
Using callbacks #
To use callbacks, just pass them as parameters to AndroidPIP constructor.
AndroidPIP _pip = AndroidPIP(
onPipEntered: () => doSomething(),
onPipExited: () => doSomeOtherThing(),
onPipMaximised: () => doAnotherThing(),
);
copied to clipboard
Using the PIP widget #
To use the widget, you need to enable callbacks first.
Import pip_widget.dart file.
Add a PipWidget widget to your tree and give it a builder or a child, and a pipBuilder or a pipChild.
import 'package:android_pip/pip_widget.dart';
class MyWidget extends StatelessWidget {
Widget build(BuildContext context) {
return PipWidget(
builder: (context) => Text('This is built when PIP mode is not active'),
child: Text('This widget is not used because builder is not null'),
//pipBuilder: (context) => Text('This is built when PIP mode is active'),
pipChild: Text('This widget is used because pipBuilder is null'),
);
}
}
copied to clipboard
You can also pass callbacks directly to PipWidget.
Using PIP Actions #
To use PIP actions, you need to specify a pipLayout preset on your PipWidget.
The current available action layout presets are focused on giving support to media reproduction controls. They are media, media_only_pause , media_with_seek_10 and media_live. Those are defined on the [PipActionsLayout] enum.
You can also add a onPipAction listener to handle actions callbacks from PipWidget. This can be defined on AndroidPIP(onPipAction: ...) too.
import 'package:android_pip/pip_widget.dart';
import 'package:android_pip/actions/pip_action.dart';
import 'package:android_pip/actions/pip_actions_layout.dart';
class MyWidget extends StatelessWidget {
ExampleVideoPlayer videoPlayer = ExampleVideoPlayer();
Widget build(BuildContext context) {
return PipWidget(
pipLayout: PipActionsLayout.media,
onPipAction: (action) {
switch (action) {
case PipAction.play:
// example: videoPlayerController.play();
break;
case PipAction.pause:
// example: videoPlayerController.pause();
break;
case PipAction.next:
// example: videoPlayerController.next();
case PipAction.previous:
// example: videoPlayerController.previous();
default:
break;
}
},
pipChild: videoPlayer,
child: videoPlayer,
);
}
}
copied to clipboard
Notes #
Multi-platform apps #
Every AndroidPIP method calls android native code, so make sure you only make a call to a AndroidPIP method when running in an Android device.
This includes AndroidPIP.isPipAvailable.
Calling AndroidPIP methods on a non-Android device will raise a MissingPluginException error.

License

For personal and professional use. You cannot resell or redistribute these repositories in their original state.

Share

• Share on Facebook
• Share on Twitter