flutter_pjsip

Description:

flutter pjsip

flutter_pjsip #

This is a Flutter plugin for the PJSIP library. It
provides a Dart API for the PJSIP library, and it is implemented using Dart FFI.
Getting started as user #
You can use this plugin as a user by adding it to your pubspec.yaml:
flutter pub add flutter_pjsip
copied to clipboard
Documentation for the API will be available later. TODO: Add link to API docs.
Getting started as hacker #
TODO: Move hacker's guide to separate document and add link to it here.
This project based on Flutter
FFI plugin,
a specialized package that includes native code directly invoked with Dart FFI.
Melos magic #
For simplicity we use Melos to manage
multi-package project. Melos is a Dart tool for managing Dart projects with
multiple packages, inspired by Lerna for JavaScript.
Install melos #
dart pub global activate melos
copied to clipboard
Prepare the project for hacking: easy way #
Before you start hacking, you need to prepare the project and install Android NDK - the minimum recommended version is 25.1.8937393. Make sure that you have Android SDK installed and ANDROID_HOME environment variable is set. Also you have to set ANDROID_NDK_HOME environment variable to the path to Android NDK.
By running the following command, melos will boostrap the project, get PJSIP source code, generate FFI bindings, and build PJSIP for all platforms:
melos prepare
copied to clipboard
Prepare the project for hacking: step by step #
Alternatively, you can execute prepare steps one by one. First, you need to install dependencies for all packages:
melos bs
copied to clipboard
Here bs means bootstrap.
Then you need to get PJSIP source code:
melos get-pjsip
copied to clipboard
Next step is to generate FFI bindings:
melos gen-ffi-bindings
copied to clipboard
Now you ready to build the project. You can build PJSIP for all platforms at once or for a specific platform:
# All platforms:
melos build
# iOS:
melos build-ios
# Android:
melos build-android
copied to clipboard
Troubleshooting #
Melos
If you have Can't load Kernel binary: Invalid SDK hash. error when running melos command, you need to run the following command:
dart pub global deactivate melos
dart pub global activate melos
copied to clipboard
This will reinstall melos and fix the issue.
Anroid NDK version
If you have configure-android error: compiler not found, please check environment settings (TARGET ABI, etc) error, make sure you have the minimum recommended version installed.
Analyze and test all packages #
Before committing your changes, you should run static analysis and all tests for all packages:
melos check-all
copied to clipboard
Alternatively, you can run static analysis and tests for all packages:
# Static analysis:
melos analyze
# Check code formatting:
melos check-format
# Tests:
melos test
copied to clipboard
Also you can run test separately:
# Dart tests (but there is no Dart tests yet):
melos test-dart
# Flutter tests
melos test-flutter
# Integration tests
melos test-integration
copied to clipboard
Intergation tests can be run on one of you devices! So, make sure that you have at least one device connected to your computer. If you have multiple devices connected, you can specify device ID (elsewise, you will get 'More than one device connected...' error).
melos test-integration -- -d iPhone
copied to clipboard
It can be applied to run other commands that includes test-integration command:
melos test -- -d iPhone
melos check-all -- -d iPhone
copied to clipboard
Versioning and publish packages #
Usually you don't need to version and publish packages manually. All heavy lifting is done by CI/CD. But if you need to do it manually, you can do it by running the following command:
# Bump version
melos version
# Publish packages
melos publish-with-hooks
copied to clipboard
Yeah, melos don't support hooks for publish command, so we need to use publish-with-hooks command instead, which runs pre-publish.sh and post-publish.sh scripts.
For creating an archive with compiled libraries, you can run the following command:
melos create-lib-archive
copied to clipboard
It will create lib.tar.gz archive in packages/flutter_pjsip/target folder. Note: this command doesn't build libraries, so you need to run melos build command before. This command is useful for creating github release artifact.
Clean up everything #
In case of any issues, you can clean up everything and start from scratch. This will clean up all packages and remove all generated files:
melos clean
copied to clipboard
You can also clean up working tree, but keep generated files (dart, binary libraries, etc):
melos clean-working-tree
copied to clipboard
This can be useful while preparing gh artifact or publishing packages.
Project structure #
We forced to move actual project to packages/flutter_pjsip folder because of Melos limitations (it's not compatible with the latest file package which is used by ffi package). So, we have the following structure:

/ - root folder with melos.yaml file
/scripts - scripts for melos
/packages/flutter_pjsip - actual project
/packages/flutter_pjsip/example - example project

The actual project flutter_pjsip project uses the following structure:


src: Contains the native source code, and a CmakeFile.txt file for building
that source code into a dynamic library.


lib: Contains the Dart code that defines the API of the plugin, and which
calls into the native code using dart:ffi.


platform folders (android, ios): Contains the build files
for building and bundling the native code library with the platform application.


android/libs and ios/Frameworks: Contains the native libraries and
frameworks that are bundled with the platform application.


Building and bundling native code #
The pubspec.yaml specifies FFI plugins as follows:
plugin:
platforms:
some_platform:
ffiPlugin: true
copied to clipboard
This configuration invokes the native build for the various target platforms
and bundles the binaries in Flutter applications using these FFI plugins.
This can be combined with dartPluginClass, such as when FFI is used for the
implementation of one platform in a federated plugin:
plugin:
implements: some_other_plugin
platforms:
some_platform:
dartPluginClass: SomeClass
ffiPlugin: true
copied to clipboard
A plugin can have both FFI and method channels:
plugin:
platforms:
some_platform:
pluginClass: SomeName
ffiPlugin: true
copied to clipboard
The native build systems that are invoked by FFI (and method channel) plugins are:

For Android: Gradle, which invokes the Android NDK for native builds.

See the documentation in android/build.gradle.


For iOS and MacOS: Xcode, via CocoaPods.

See the documentation in ios/flutter_pjsip.podspec.
See the documentation in macos/flutter_pjsip.podspec.


For Linux and Windows: CMake.

See the documentation in linux/CMakeLists.txt.
See the documentation in windows/CMakeLists.txt.



Binding to native code #
To use the native code, bindings in Dart are needed.
To avoid writing these by hand, they are generated from the header file
(src/flutter_pjsip.h) by package:ffigen.
Regenerate the bindings by running flutter pub run ffigen --config ffigen.yaml.
Invoking native code #
Very short-running native functions can be directly invoked from any isolate.
Longer-running functions should be invoked on a helper isolate to avoid
dropping frames in Flutter applications.
Flutter help #
For help getting started with Flutter, view our
online documentation, which offers tutorials,
samples, guidance on mobile development, and a full API reference.