Skip to content

FreeFlight 6 USA (phone app) and the firmware it bundles

Installed 2026-10-01 over mcadb on the lab phone (Ulefone Power Armor 18T, Android 12). Everything below was read from the pulled APKs on the host, not from the running app. The app has not been launched or paired with the drone.

  • FreeFlight Pro (com.parrot.freeflight3), the original Bebop 2 app, returns “Item not found” on this phone’s Play Store. Delisted or region-limited; we did not tell which.
  • A Play search for “parrot freeflight” returned one Parrot SA app: FreeFlight 6 USA, package com.parrot.freeflight6usa, version 6.10.6 (versionCode 61006205, minSdk 24, targetSdk 36), 1.9 stars over 334 reviews.
  • Does FreeFlight 6 USA connect to a Bebop 2? No. Its device enums list only ANAFI drones and Skycontroller 3 and later (“What the app supports”, below); the live test agreed. Earlier wording here said “no evidence either way”. Adjacent facts: the FreeFlight Pro user guide (docs/parrot/freeflight-pro/user-guide.pdf) covers Bebop, Bebop 2, Disco and both Skycontrollers, and Parrot’s Bebop page ships that guide, not FreeFlight 6. An earlier line in this session called FreeFlight 6 ANAFI-only; that was unsupported. Record it as: no Bebop firmware in the bundle, Bebop support unverified.

Play delivers it as an app bundle: six split APKs, about 420 MB, saved under apk/freeflight6usa/ with a SHA256SUMS file. The six APKs are in Git LFS (*.apk in .gitattributes); the extracted/ tree (unpacked firmware, 100+ MB) is excluded locally via .git/info/exclude and regenerated from split_firmwares.apk. Reinstall with adb install-multiple *.apk from that directory.

Split Size Role
base.apk 56 MB app code
split_config.arm64_v8a.apk 38 MB native libraries
split_config.en.apk, split_config.xxhdpi.apk 0.1, 7.8 MB strings, assets
split_lionne.apk 18 MB feature module, not examined
split_firmwares.apk 309 MB bundled update images

Bundled firmware (split_firmwares.apk, assets/firmwares/)

Section titled “Bundled firmware (split_firmwares.apk, assets/firmwares/)”
Path Version Size
mpp4/mpp4-s905x3 7.7.2 94 MB
anafi/anafi-ua 1.10.7 66 MB
anafi/anafi-mark3 1.10.7 66 MB
mppua/mppua-linux 3.2.3 43 MB
mpp3/mpp3-linux 1.8.1 41 MB

No Bebop 2 firmware is in the app. Nothing for the drone, and nothing in the Bebop 2 / Skycontroller 1 or 2 generation. The firmware this repo studies (4.7.1) has to come from elsewhere, as it already does.

mpp3 1.8.1 is the Skycontroller 3, not our controller

Section titled “mpp3 1.8.1 is the Skycontroller 3, not our controller”

Unpacked to .../mpp3-linux/1.8.1/unpacked/ (also untracked).

  • etc/boxinit.rc sets ro.product.model to ${file:/data/model.txt:"Skycontroller 3"}. That is the evidence for the name; build.prop only says mpp3.
  • Build: Jenkins, 2021-09-03, mpp3-linux-1.8.1, project group drones.
  • Container: Parrot PLF! header, then a tar of Qualcomm APQ8009 parts: appsboot.mbn, sbl1.mbn, rpm.mbn, tz.mbn, a boot image, a recovery image, and mpp3-linux.ubi (31 MB rootfs). A 2,305-byte signature file is included, so updates are signed.
  • Kernel command line carries boxinit.hardware=mpp3; the device tree is derived from msm8909-pm8916-mpp2-common.dtsi.
  • Rootfs extracted with uvx --from ubi_reader ubireader_extract_files. Init is Parrot’s boxinit (/etc/boxinit.d/*.rc, 30 files), not systemd.

Services of note in the rootfs, from the .rc files (not run, so these say what is configured, not what is reachable):

  • adbd starts only when ro.debuggable=1 or rw.debuggable=1. Off by default.
  • inetd runs as root with one line in /etc/inetd.conf: FTP on port 21 (ftpd -wS /var/lib/ftp). telnetd exists in /usr/sbin but no init file or inetd line starts it.
  • factory_dbgauth (/usr/bin/debugauth --persist /factory/) starts only when ro.factory.serial is set. Looks like a challenge-style debug unlock; not read.
  • webserverd starts when mpp.open=1; also udhcpd, dnsmasq, usbnetd, streamd, mppd, aoad, wifi.

What this means for our Skycontroller question

Section titled “What this means for our Skycontroller question”
  • Skycontroller 3 pairs with ANAFI. The notes already hold a different controller image, nap-linux-2.0.0-rc3 (firmware/extracted/skycontroller-nap/, see SKYCONTROLLER_NOTES.md). That image never names its product; the “Skycontroller 2” label comes from Parrot’s download page and Ryan’s statement, and it carries etc/mppd/bebop mapping sets. mpp3 is a different, later device; do not fold its findings into the nap notes.
  • Ryan confirmed 2026-10-01 that the FPV pack controller is a Skycontroller 2 and that v0.9.1 is printed on the back of the unit. Both are his reading; no photo or capture of the label is in the repo.
  • A printed label cannot be the firmware version, because firmware is updated after the label is printed. It is most likely a hardware or production revision. So v0.9.1 says nothing yet about which firmware the unit runs, and does not make it older or newer than the nap-linux-2.0.0-rc3 image. grep for 0.9.1 across firmware/ and the notes found no hit, which is expected for a hardware number.
  • The unit’s firmware version is still unread. Ways to read it: the FreeFlight app once the controller is connected, or the controller’s own screen or boot display, if it has one. Q: open.
  • The shared Qualcomm-plus-boxinit lineage is the only link between the two. It may help read SC2 later, but nothing here has been compared against it yet.
  1. Launch the app and see whether it offers Bebop 2 at all (Wi-Fi to the drone).
  2. Look at split_lionne.apk (what it is) and base.apk strings for bebop / ardrone / ARSDK to answer the Q above without a flight.
  3. Read debugauth and /etc/inetd.conf handling on the SC3 only if it turns out to matter for SC2.

First launch (2026-10-01, phone on starla, no drone in range)

Section titled “First launch (2026-10-01, phone on starla, no drone in range)”

Screenshots in artifacts/screenshots/2026-10-01/ (ff6-*.png).

  • Splash: Parrot branding, ANAFI USA-style drones with first-responder photos.
  • Terms of Use screen (Parrot Drones SAS). Ryan accepted it himself; we did not. The text says some services need a my.Parrot account. No account was created.
  • Setup wizard: “I have a controller” or “I’m using my smartphone”. The smartphone path says “connect your smartphone to the drone’s Wi-Fi”, with an example SSID ANAFI-… and a tip to scan the QR code in the drone’s carrying case. Nothing in the wizard mentions Bebop. That is mild evidence the app targets ANAFI-family drones; it does not show a Bebop 2 would be refused.
  • Not tried: joining the drone’s Wi-Fi, the “I have a controller” path, or any sign-in. Bebop 2 support is still Q: open until the app sees the drone.

Test against the live Bebop 2 (2026-10-01)

Section titled “Test against the live Bebop 2 (2026-10-01)”

Phone joined Bebop2-XXXXXX (open AP; phone got 192.168.42.78, drone 192.168.42.1, neighbor MAC prefix a0:14:3d, a Parrot OUI; full address kept out of git). Agreed with bebop-main first, which had no live ARSDK session at the time. No flight, no commands, no sign-in, no handshake attempt on 44444, TRY and Register untouched.

  • Result: the app did not detect the drone. The main screen’s drone and controller status icons stayed greyed out; the setup wizard never advanced from its ANAFI instructions screen, before or after a force-stop and relaunch. Screenshots: artifacts/screenshots/2026-10-01/ff6-*.png.
  • Reachability: from the phone’s adb shell, ping to the drone was 100% loss while mobile data was on and 0% loss (2.1 to 5.2 ms) after svc data disable. Android flags the AP “no internet” and routes shell traffic elsewhere. The app’s own routing may differ, so the negative is strong but not airtight.
  • Not tested: whether a connect would succeed if forced. That would be a second ARSDK handshake and was out of scope. bebop-main assumes handshake status != 0 means “already has a controller”, never verified.
  • Taken together with the bundle (no Bebop firmware; a few bebop strings, 6 in dex and 7 in native libs, plausibly the SDK’s device-type table) and the ANAFI-only wizard, FreeFlight 6 USA is best treated as not a Bebop 2 app. The Bebop 2 app remains FreeFlight Pro (com.parrot.freeflight3), which is not on this phone’s Play Store. A copy from elsewhere would be needed.
  • Phone restored: back on starla, Bebop2 network forgotten, mobile data on, app closed. Screen timeout was left at 600 s (original value not recorded).

How the controller connects (static analysis, 2026-10-02)

Section titled “How the controller connects (static analysis, 2026-10-02)”

Sources: the nap-linux-2.0.0-rc3 rootfs in firmware/extracted/skycontroller-nap/ (init .rc files, start_dnsmasq_wlan1, dnsmasq.conf) and the FF6 APK. Nothing here was observed on a running controller, and which image Ryan’s unit runs is still unread, so read these as “what that image is configured to do”.

Controller image, three links:

  • To the drone: Wi-Fi client. wifid --mode STA --ip 192.168.42.3 --dhclient (chip qca9375) joins the drone’s own AP, in the 192.168.42.x range the drone hands out. The controller is a client of the drone, like the phone was.
  • To the phone, option 1: its own access point. wifid-ap --mode AP --ip 192.168.44.1 (a second chip, wl18xx; disabled until gps.socket.ready=1), with hostapd.conf and dnsmasq handing out 192.168.44.10 to .100. hostapd.conf has no ssid line, so the name is set elsewhere (not found yet).
  • To the phone, option 2: USB. aoad (“Android Open Accessory manager”) uses libusb to drive the phone into accessory mode. iw, inetd also present.

The controller is a relay, not just a radio. start_dnsmasq_wlan1 turns on IP forwarding and NAT (MASQUERADE out wlan0), and DNATs three FTP ports from the controller to the drone at 192.168.42.1: 121 to 21 (media), 151 to 51 (update), 161 to 61 (flight plan). So a phone on the controller’s AP reaches the drone’s media over FTP through the controller.

Answer to “does the drone connect to both?”: from this image, no. The drone has one Wi-Fi AP and its clients are the controller and, if joined directly, the phone. In the controller path the drone sees the controller; the phone sits behind it over USB or the controller’s AP. Not yet observed with a drone.

App side: the manifest declares USB_ACCESSORY_ATTACHED on UsbDetectionActivity (so the app wakes when a controller is plugged in) and allows cleartext HTTP to 192.168.42.1 and 127.0.0.1 (res/xml/network_security_config.xml). The accessory filter (res/xml/gsdk_usb_rc_filter.xml) lists manufacturer Parrot with models Skycontroller 3, Skycontroller ua, Skycontroller 4, Skycontroller 4 Black, Skycontroller 5. It does not list “Skycontroller 2” or Skycontroller 1.

What the app supports (decompiled, 2026-10-02) — answers the Bebop 2 question

Section titled “What the app supports (decompiled, 2026-10-02) — answers the Bebop 2 question”

Decompiled base.apk with jadx 1.5.6 on Java 17 (the default Java here is 8 and jadx dies with UnsupportedClassVersionError). The app is built on Parrot’s GroundSDK. Its hardware lists are enums, not strings, so this is definitive for this build:

  • Drone.Model: ANAFI_4K (2324), ANAFI_THERMAL (2329), ANAFI_2 (2330), ANAFI_UA (2331), ANAFI_USA (2334), ANAFI_3 (2335), ANAFI_3_USA (2336).
  • RemoteControl.Model: SKY_CONTROLLER_3 (2328), _UA (2332), _4 (2333), _4_BLACK (2337), _5 (2338), _UA_2 (2339).
  • No Bebop, Bebop 2, Disco, Skycontroller 1 or Skycontroller 2. FreeFlight 6 USA cannot drive a Bebop 2 or Ryan’s controller by construction. This closes the open question; the live test (drone icon stayed grey) agrees.
  • The stray “bebop” hits are leftovers, not support: the Ardrone3.* command names in libsdkcore.so (the ARDrone3 feature set the Bebop uses, shared with ANAFI) and an unused drawable img_bebop2_oriented.

Two transports in the app, and how each finds a device

Section titled “Two transports in the app, and how each finds a device”

libsdkcore.so has two backends (arsdk_backend_net_*, arsdk_backend_mux_*):

  • Net (Wi-Fi): ArsdkNetBackend, driven from native code through an ArsdkWifiBackendController the decompile did not surface. Discovery mechanism not found in the Java; not yet read in the native library.
  • Mux (USB): ArsdkMuxBackend receives the open accessory’s file descriptor and multiplexes channels over it (mux_channel_open, _ip_request, _ip_connected, plus arsdkcore_tcp_proxy_*). IP traffic to the drone therefore rides inside the USB link, and HostResolver resolves hostnames on request. This is the phone-to-controller link for the models above.
  • The ARSDK handshake fields c2d_port and d2c_port are present in the library, matching what bebop-main documents for the Bebop.

Bottom line on the topology (what is and is not established)

Section titled “Bottom line on the topology (what is and is not established)”
  • Established from the nap image: controller is a Wi-Fi client of the drone (192.168.42.3), can host its own AP (192.168.44.1), relays FTP to the drone, and has a USB accessory daemon (aoad, libusb) that pushes the phone into accessory mode.
  • Established from the app: for the models it supports, USB accessory plus a mux carries the session.
  • Not established: how a Skycontroller 2 actually talks to a phone when the phone runs the older FreeFlight Pro. The nap image has both an AP and USB, and the app that would use them is not on hand. Q: open. What triggers the AP (wifid-ap starts on gps.socket.ready=1) and where its SSID is set are also unread.

The right app: FreeFlight Pro 5.2.7 (found 2026-10-02, NOT installed yet)

Section titled “The right app: FreeFlight Pro 5.2.7 (found 2026-10-02, NOT installed yet)”

FreeFlight Pro (com.parrot.freeflight3) is the Bebop 2 / Disco app and is gone from the Play Store. archive.org has one copy: com.parrot.freeflight3_527_apksos.com (uploaded 2024-07-11 by an individual, not Parrot, mirrored from apksos.com; description says Bebop 2 and Disco). Stored at apk/freeflight-pro-5.2.7/ (APK 79 MB, OBB expansion 158 MB, SHA256SUMS); not committed.

What was checked:

  • Download matched archive.org’s MD5 (c40afd51…). That proves transfer only.
  • APK identity: package com.parrot.freeflight3, version 5.2.7 (code 50207201), minSdk 17, targetSdk 28; arm64-v8a and armeabi-v7a libraries.
  • Signature: v1 and v2 valid. Signer CN=Parrot Mykonos, O=Parrot, Paris, FR, created 2011-08-26, SHA-1 c63be098…2827, SHA-256 88C44409…D045C2.
  • Cross-checked against independent sources (2026-10-02):
    • APKMirror’s FreeFlight Pro 5.2.7 page (uploaded 2019-10-04) lists the same versionCode 50207201, size 75.70 MB (ours: 79,374,205 bytes = 75.69 MiB), SHA-1 and SHA-256 above, and the same subject. Its 5.2.6 page lists the same fingerprints, so the key is stable across releases.
    • The same key signs AR.FreeFlight 2.4.15 (archive.org ar.-free-flight-2.4.15), a much older Parrot app. That item is from the same uploader, so it only shows key continuity, not independence.
    • What this does not prove: APKMirror shows no file hash, so the bytes are matched by size, version code and signer, not byte for byte. A re-signed fake would carry a different fingerprint, which is what the match rules out.
    • FF6 (Play) is signed by Google’s Play key and cannot be compared.
  • Static scan of dex and native libs: hosts are academy.ardrone.com, parrot.com, Parrot accounts, Google APIs, Crashlytics, u-blox assist data; bundled packages are com.parrot.arsdk, controller, mux, engine3d, Glide, Gson, Fabric. Nothing unexpected, and a scan like this cannot prove the absence of tampering.
  • Permissions requested include accounts, location, camera, phone state and storage. Use on the lab phone only, no Parrot sign-in.
  • Does it support Skycontroller 2? The dex has com.parrot.mux and com.parrot.controller; not yet decompiled. Q: open.

FreeFlight Pro installed on the lab phone (2026-10-02)

Section titled “FreeFlight Pro installed on the lab phone (2026-10-02)”
  • adb install of the 5.2.7 APK succeeded (versionCode 50207201, Android 12 accepts targetSdk 28). The 158 MB OBB was pushed to /sdcard/Android/obb/com.parrot.freeflight3/; its SHA-256 on the phone matches the host copy.
  • First launch asked for storage (allowed: it reads the OBB) and location (allowed, “while using the app”; the app says it cannot run without it, which fits Android needing location to read the Wi-Fi name). Camera, accounts and phone state were not asked for. The My.Parrot sign-in was declined with “Connect later”; no account exists or was created.
  • Home screen: “Connect to a drone: Not connected” with a Connect button, and a controller icon. Screenshots in artifacts/screenshots/2026-10-02/ffpro-*.png.
  • Not yet tried: joining the drone’s Wi-Fi. Asked bebop-main first.
  • Trap: with the drone’s ADB link registered in this workstation’s adb server (192.168.42.1:9050), mcadb calls without a device id fail with “more than one device”. Use devices_use or pass the phone’s serial every time, so a command can never land on the aircraft.

FreeFlight Pro against the live Bebop 2 (2026-10-02)

Section titled “FreeFlight Pro against the live Bebop 2 (2026-10-02)”

Agreed with bebop-main first (it held no ARSDK session); Ryan confirmed no propellers were mounted. Phone joined Bebop2-XXXXXX (192.168.42.78), mobile data off, then I tapped Connect on the app’s home screen.

  • It connected. The next screen I captured was the app’s “Drone memory” gallery: 0 media, 7.1 of 7 GB free (drone storage as read by the app, over the drone’s FTP). So FreeFlight Pro reaches a Bebop 2 where FreeFlight 6 did not even see it. Screenshot artifacts/screenshots/2026-10-02/ffpro-connect1.png.
  • Not observed: the connected home screen, the model/name the app shows for the drone, any video preview or its resolution, and whether a firmware update was offered. I took one screenshot after the tap and did not navigate further because Ryan needed to swap the battery. Q: open, including whether the app shows 856x480 video (what bebop-main measures on the wire).
  • No update accepted, no flight control touched, no sign-in.
  • Second-controller question, answered by bebop-main’s experiment: a second ARSDK client is NOT refused. The drone accepts it and silently redirects telemetry to the newcomer; the first session keeps reporting connected while starved (frames froze at 264 while the second took 164). Fully documented in its own notes; recorded here only because it is why we coordinated.
  • Cleanup: app force-stopped, drone network forgotten, phone back on starla (192.168.1.201) by itself once the drone lost power. svc data enable was issued; I could not read the mobile-data state back, so check it is on.
  • Phone screen timeout is still 600 s from the earlier test; original unknown.

FreeFlight Pro: connected session, second run (2026-10-02)

Section titled “FreeFlight Pro: connected session, second run (2026-10-02)”

After the battery swap, bebop-main released the link and said go. Phone on Bebop2-XXXXXX (mobile data off), app launched, no props mounted.

  • Auto-connect: on launch the home screen already showed the drone as Bebop2-XXXXXX (the app identifies it by its SSID, not a model name), battery 100 %, 7.1 GB free, Wi-Fi icon lit. No sign-in; My.Parrot declined earlier.
  • Menu (hamburger): Login, Gallery, Flight Plan, What’s new, Drone school; version label FreeFlight Pro 5.2.7. No settings or about-drone page there.
  • Piloting screen (Fly & Film): video area was black (dark scene) with a faint red smear; I cannot say what resolution the live view uses. Top bar shows a 1080p badge, which is the recording setting. A hand-launch tutorial popup came first; I chose “No, thanks” (the other button would enable the feature). I did not press TAKE-OFF or any stick.
  • Settings tabs (four only): Interface, Piloting, Safety, Video. No product or firmware page, no boot count, flight count or flight time anywhere, so bebop-main’s request to confirm flight 48 / 7946 s from Parrot’s app could not be answered from this build’s UI. No firmware-update prompt appeared.
  • Video tab values: recording resolution 1080P (720P available), quality HIGH, frame rate 30 FPS, roll stabilization option present. The app’s own caption reads “Set 720p to improve live video stream resolution.” That is Parrot’s software saying 1080p recording gives a lower-resolution live stream, which fits bebop-main’s wire measurement of 856x480 (rec1080_stream480). It does not itself state 480, so this is agreement, not a measurement.
  • Piloting and Safety tabs: values are UNRELIABLE as first written. I read them with sort -u, which scrambled the order, then paired values to labels by guesswork. That produced “max altitude 2000 m, max distance 30 m”, which is swapped: the aircraft reports altitude 30 m, distance 2000 m, before and after (per bebop-main). The Piloting numbers (1.0 m/s, 8 deg, 80 deg/s) had four labels for three values, so their pairing is also unproven. Treat the aircraft’s own reports as the source, not this note. Lesson: dump the UI in document order and keep each label next to its value.

Slip to disclose: while scrolling the Settings tab list I swiped at the left column and the Interface page’s FPV Mode flipped from AUTO to MANUAL (seen in the next screenshot). I tapped AUTO to restore it and a following screenshot confirms AUTO. FPV Mode is an app-side interface preference, not a drone parameter, and I did not knowingly change a drone value, but the cause was my swipe, not the app. (See the next section: the app itself did change drone settings.) I switched to reading the screen with uiautomator dump (via host adb -s <serial> exec-out uiautomator dump /dev/tty) instead of gestures; dumping through the mcadb shell tool mangles quotes.

Correction: FreeFlight Pro writes settings to the drone on connect

Section titled “Correction: FreeFlight Pro writes settings to the drone on connect”

Earlier text in this file says no settings were changed. That was wrong. bebop-main compared the aircraft’s own telemetry before and after the sessions:

setting before after
geofence (NoFlyOverMaxDistance) 0, off 1, on
return-home delay 30 s 3 s
banked turn 0 1

These live in /data/dragon.conf, which survives power cycles, so a reboot does not explain them, and every other value in that file was unchanged (max altitude 30, max distance 2000, max tilt 8, vertical speed 1, rotation speeds, hull protection, outdoor, autorecord, country).

  • Mechanism: the app replays its stored settings to the drone on every connect. Confirmed two independent ways: the decompiled code (save, update, restore, below) and the drone’s own log for the second session (below). An earlier version of this note called the mechanism “unproven” after a wrong reading of that log; see “Resolved” at the end of this file.
  • Which run did it: the first (before the battery swap) almost certainly. A fresh install has an empty local store, so it replayed its built-in defaults over the drone’s own values; the first session’s log was lost to the reboot, so this part is inference. The second session replayed again, but by then the stored values matched.
  • Consequence that matters: the return-home delay dropped from 30 s to 3 s, which sets how long a lost link is tolerated before the aircraft flies home by itself. Geofence-on and banked-turn are the lesser effects. Not reverted; changing the aircraft is Ryan’s and bebop-main’s call.
  • What survives, and is the useful part: connecting this app changed settings nobody touched, and only a before-and-after read revealed it. Treat a first connect as potentially a write: read the reported settings (or dragon.conf) before and after, and do not assume “I only looked” means nothing changed. Why it happens is not established.

Also reported by bebop-main: the freshly fitted battery read 0 % for a while after the swap, refreshing every few seconds, probably the gauge learning a new pack. Not assumed benign.

What was restored on the aircraft (2026-10-02, by bebop-main)

Section titled “What was restored on the aircraft (2026-10-02, by bebop-main)”

Not a clean revert. bebop-main asked Ryan directly (these are envelope-tier commands) and he chose “revert, and also tighten max distance”. Those two conflict, so the geofence was left on. Values read back from the aircraft:

setting original app set now
return-home delay 30 s 3 s 30 s, restored
banked turn 0 1 0, restored
max distance 2000 m 2000 m 150 m, tightened
geofence (NoFlyOverMaxDistance) 0, off 1, on 1, on, deliberately kept

Why: Parrot’s own wording for the geofence command is “1 if the drone can’t fly further than max distance, 0 if no limitation on the drone will be done”. With it off the distance limit is not enforced, so tightening to 150 m would be cosmetic. Turning it off is one command if Ryan wants that, and would make 150 m advisory only. Full detail: drone state, “Settings restored, and one deliberately not restored” (commit e16a2bd). The aircraft was powered down afterwards, so these are the last values read.

Say it accurately: two of the three app changes were reverted; the geofence was kept on on purpose, and max distance went from 2000 m to 150 m.

Related trap found while chasing a 0 % battery reading (details in protocol.md): the aircraft sends BatteryStateChanged from two places, one with the true value and one constant 0. A client that keeps the newest frame reports a healthy Bebop 2 as flat.

Decision (Ryan, 2026-10-02): geofence stays on. With max distance at 150 m the limit is enforced. No change to the aircraft was needed; it was already in that state.

Open-source alternative, and why we are not taking it (2026-10-02)

Section titled “Open-source alternative, and why we are not taking it (2026-10-02)”

Asked: what is the ArduPilot / open-source equivalent of the phone app?

  • ArduPilot route: stock firmware already has a hook. Button press 3 runs shortpress_3.sh, which calls kk (killall -KILL dragon-prog) and then starts /usr/bin/arducopter.sh (service 50-arducopter.rc: MAVLink out on udp 192.168.42.255:14550 and :14551, GPS on /dev/ttyPA1). Any MAVLink ground station then works as the app: QGroundControl (desktop and Android), Mission Planner, APM Planner 2, MAVProxy. The build is in firmware/ardupilot/.
  • Parrot-protocol route: keeps stock firmware. ARSDK3 definitions are open; libraries are pyparrot, bebop_autonomy (ROS 1 only) and mcbebop. Olympe is ANAFI only.
  • Inference, not tested: in ArduPilot mode the video very likely stops. The camera, ISP and H.264/RTP pipeline appear to be linked into dragon-prog (HARDWARE_REVERSE_ENGINEERING.md, camera section, flagged there as an agent claim), kk kills exactly that process, and the ArduCopter service starts nothing for video. So no ARStream2 on 55004 and no Parrot ARSDK handshake until a reboot returns Dragon. Confirming means installing ArduCopter on the aircraft, which needs Ryan’s approval and bebop-main’s link.
  • Decision (Ryan, 2026-10-02): not pursuing a QGroundControl simulator test on the Android phone. Work continues with the Pine64 phone (pinephone session: FPV goggle viewer listening for RTP H.264 on UDP 55004, flown with a Skycontroller 2), which is mid-test and must not be touched from this session.
  • Hard safety rule, from bebop-main’s measurement: a second ARSDK handshake silently takes telemetry from the first controller. Never handshake with the aircraft while the SC2 or anything else is flying it.

Android phone (Ulefone) status: both Parrot apps force-stopped, drone network forgotten, mobile data on. Screen timeout left at 600 s (original value unknown). Ryan has since unplugged it (2026-10-02), so that cannot be changed from here; reset it by hand if it matters. Ownership of the Ulefone is unconfirmed. The two Parrot apps and their permissions (storage, location for FreeFlight Pro) are still installed on it.

What the drone logged for FreeFlight Pro’s second session (from bebop-main)

Section titled “What the drone logged for FreeFlight Pro’s second session (from bebop-main)”

The drone’s own log records commands it receives as Cmd Rx under the COMMANDS tag, plus the handshake JSON. For the second session (2026-10-02) it shows only:

[107.49] NETWORK_DISCOVERY Received {"d2c_port":54321,"controller_name":"com.parrot.freeflight3, 5.2.7", ...}
[107.90] COMMANDS Cmd Rx : Set current date : 2026-10-02 (10)
[107.90] COMMANDS Cmd Rx : Set current time : T033507-0600 (12)
[107.91] COMMANDS Cmd Rx : all settings
[109.10] COMMANDS Command "EndOfSettingsCmd" ACK received
[109.11] COMMANDS Cmd Rx : all states
  • Not the whole sequence. That excerpt is only the Cmd Rx lines, and the drone does not log a setting write as Cmd Rx (it logs the effect, see “Resolved”). So “no setting-change command” was wrong. d2c_port was 54321 (pyparrot uses 43210), and controller_name is the app’s package and version, which tells its sessions from ours.
  • Only the second session is visible; the first session’s log was lost to the reboot. So the on-connect sequence is known for one session, not two.
  • FreeFlight Pro sets the drone’s clock. The Bebop 2 has no battery-backed clock and boots at the epoch, so timestamps on it are uptime until a phone app connects and real wall-clock afterwards. Read file times and log stamps with that in mind. This also answers an earlier open question: something does set the date from the controller side, just not our tools.
  • Method note: a drone-side Cmd Rx log is the way to see what an app sent when you cannot capture its traffic. It covers commands the firmware logs, which is not necessarily every command.

FreeFlight Pro decompiled: what the app does on connect (2026-10-03)

Section titled “FreeFlight Pro decompiled: what the app does on connect (2026-10-03)”

jadx 1.5.6 on Java 17 over apk/freeflight-pro-5.2.7/com.parrot.freeflight3.apk (5,504 Java files; output is in the scratch directory, regenerate as needed). ARSDK itself is native, so this covers the app’s own logic, not the wire.

A concrete replay mechanism exists (QuadcopterModel, the connection listener, about line 311):

  1. drone connects, a new device controller is assigned
  2. mOfflineEngine.save() snapshots the app’s own copy of the settings (loaded from its local store, or built-in defaults if the store is empty)
  3. update() reads the drone’s reported state into the model
  4. mOfflineEngine.restore() replays the snapshot to the drone through the normal setters, then saveToStore()

QuadcopterOfflineEngine caches and replays about 20 settings, including all three that changed: return-home delay (setReturnHomeDelay), geofence (shouldBlockBeyondMaxDistance via userRequestedPilotingSettingsNoFlyOverMaxDistance) and banked turn (setBankTurn), plus max altitude and distance, tilt and speeds, return-home type, hull protection, video resolution, recording mode, frame rate, anti-flicker, auto-record, time-lapse and roll stabilisation.

The app’s built-in defaults match two of the three observed values:

  • return-home delay default 3 s (BebopPreset.RETURN_HOME_DELAY_STATE, range 0 to 120): the drone ended on 3 s
  • banked turn default on (BANKED_TURN_STATE; Film preset on, Racing preset off): the drone ended on 1
  • geofence: inconclusive. DronePreset.DISTANCE_RESTRICTION_STATE = ToggleState.createFromValue(true, false) and I could not tell which argument is “enabled” without reading ToggleState. The drone ended on geofence on.

The pattern fits the first session: a fresh install has an empty store, so the snapshot is the defaults, and restore writes defaults over the drone’s own values. That is the same story as “pushes its stored preferences on connect”, now with a code path behind it.

The earlier contradiction is resolved (see “Resolved” below): the drone’s log does show the app’s writes in the second session, as ..._MSG_SET_... lines.

Status of the claim: established, from the app’s code and the drone’s log independently. The user-facing advice is unchanged: read settings before and after a first connect. Also found: the app has piloting presets (Film, Racing) that set tilt, speeds and banked turn; the Piloting tab’s modes correspond to them.

Resolved: the log did show the writes (2026-10-03, from bebop-main)

Section titled “Resolved: the log did show the writes (2026-10-03, from bebop-main)”

The drone does not log a setting write as a Cmd Rx line; it logs the effect under BEHAVIOUR_SETTINGS_PLATFORM as a ..._MSG_SET_... line. Re-reading the second session’s window with that query:

[+0.44] BEHAVIOUR_FEATURE_SETTINGS_MSG_GET_NO_FLY_OVER_MAX_DISTANCE : 1 (drone answering "all settings")
[+2.41] Return Home delay after disconnection set to 3
[+2.45] BEHAVIOUR_FEATURE_SETTINGS_MSG_SET_NO_FLY_OVER_MAX_DISTANCE : 1 (the app writing)
[+3.77] BEHAVIOUR_FEATURE_SETTINGS_MSG_SET_MAX_DISTANCE : 2000.000

GET_ is the drone reporting its own state; SET_ about two seconds after connect is the app’s restore(), after the save/update round trip, as the decompile predicts. So: the app replays its stored settings to the drone on every connect, and a fresh install replays its defaults.

  • Practical consequence: the app wrote max distance 2000 in that session. After the 150 m tightening (bebop-main, 2026-10-02), connecting FreeFlight Pro again will most likely write 2000 m back, and may write the other stored values too. Do not connect it to this aircraft without expecting that; read the settings before and after.
  • Method lesson: absence in a log is evidence only if you know what presence looks like. A check that a known write (your own) produces the line you searched for would have caught this.
  • Geofence default, resolved by reading the code (2026-10-03): the replay does not use the UI toggle (DronePreset.DISTANCE_RESTRICTION_STATE, enabled=true, state=false). It replays an integer, mFlightDistanceRestrictionStatus, which starts at 0 (DroneModel), and the engine executes shouldBlockBeyondMaxDistance(value == 0), so 0 means block, which sends NoFlyOverMaxDistance(1): geofence on. A fresh install therefore turns the geofence on. This matches the drone’s log (SET_NO_FLY_OVER_MAX_DISTANCE : 1). Read from decompiled code, not run.
  • Privacy: a drone’s ckcm.bin carries the CPU id, serial number halves, names of controllers that connected, and GPS first-fix coordinates (a home address if flown at home). Quote single lines only, check what surrounds them, and never attach the file.

How the Skycontroller 2 reaches the app, and the app reaches the plane (2026-10-03)

Section titled “How the Skycontroller 2 reaches the app, and the app reaches the plane (2026-10-03)”

Sources: FreeFlight Pro 5.2.7 decompiled (app side); the nap-linux-2.0.0-rc3 controller image, static (controller side, in SKYCONTROLLER_NOTES.md and skycontroller-stick-path.md). Nothing here was observed on a running Skycontroller 2; no USB session has been captured, and which image Ryan’s unit runs is unconfirmed (see the v0.9.1 note above).

Phone to controller: USB accessory, one cable, one multiplexer

Section titled “Phone to controller: USB accessory, one cable, one multiplexer”
  • The app’s accessory filter (res/xml/usb_accessory_filter.xml) is manufacturer Parrot, models Skycontroller 2 and Skycontroller 2P. UsbAccessoryMux also accepts the generic model Skycontroller. So FreeFlight Pro does name Ryan’s controller generation; FreeFlight 6 does not (its filter starts at 3).
  • Sequence in UsbAccessoryMux: USB_ACCESSORY_ATTACHED intent, then Android’s permission prompt, then UsbManager.openAccessory() returns a file descriptor, then new Mux(fd) (native libmux.so) and a reader thread named muxThread. An ARDiscoveryMux runs on a channel of that mux and announces the controller as a discovered device; ARDiscoveryDevice then treats it as network type USBMUX (alongside plain Wi-Fi and BLE). Connecting sends a connect request with a JSON body through the mux (ARDiscoveryMux.connect).
  • The controller’s side of this is aoad (Android Open Accessory daemon, libusb) pushing the phone into accessory mode, and mppd acting as an ARSDK device on a mux backend (arsdk_backend_mux_*). Static evidence only.

Native strings in libarnetworkal.so, libarstream2.so and libarutils.so show each traffic type has a mux path:

Traffic Evidence
commands and telemetry ARNetworkALManager.initMuxNetwork(mux), ARNETWORKAL_MuxNetwork_PushFrame/Receive
video (RTP) ARSTREAM2_RtpReceiver_StreamMuxSetup, _ControlMuxSetup, _MuxRecvMmsg
FTP (media, update, flight plan) ARUtilsManager for USBMUX opens FTP through the mux with destination "drone" or "skycontroller"

So over USB there is no IP network between phone and controller at all, which is why there is nothing to sniff on a Wi-Fi side. Not checked: the mux framing itself (libmux); I believe Parrot publishes it as libmux in Parrot-Developers on GitHub but have not verified that.

Controller to plane: a relay, with two roles

Section titled “Controller to plane: a relay, with two roles”

mppd is an ARSDK peer on both sides: a device toward the phone (mux) and a controller toward the drone (Wi-Fi client at 192.168.42.3, net backend, discovery over Avahi). Per the stick-path note:

  • Own sticks. The bottom board’s stick values go through shaping (expo, squaring) and a mapper into Ardrone3.Piloting.PCMD frames built every 50 ms (20 Hz), with a flag that clears after 5 consecutive zero ticks (~250 ms).
  • App relay. In app-source mode the app’s PCMD arrives over the mux and the controller forwards it re-stamped. Button and camera commands the app sends (take-off, landing, return home, camera orientation, record) travel the same way.
  • Handoff. Skyctrl.CoPiloting.SetPilotingSource selects who flies: 0 the controller’s sticks (the default, and the fallback when the drone or link drops), 1 the app. No authorisation check was seen. The meaning of 0/1 is inferred.
  • Mapper. Stick and button mapping lives on the controller and is reported to the app as events; the app does not poll raw sticks.
  • Media. FTP is NAT’d through the controller: ports 121, 151 and 161 on the controller forward to 21 (media), 51 (update) and 61 (flight plan) on the drone.
  • Failsafe. No controller-side stale-command watchdog was found: the 20 Hz timer keeps re-sending the last values. Whether the drone times out stale PCMD is open.
  1. The live behaviour of any of this: no captured SC2 session, so every claim above is code, not observation.
  2. The controller’s own message definitions (Skyctrl, Mapper, Drone_manager). Only names from mppd strings; the XML is not vendored.
  3. The mux wire format and the connect-request JSON.
  4. Whether video reaches the phone by the controller proxying the drone’s RTP, or the controller re-publishing it. Not read.
  5. How the app’s Mapper and Skyctrl calls compare with what FreeFlight Pro sends (this app’s controller/ package is the place to look).
Section titled “Plan: capturing the phone to Skycontroller 2 link (2026-10-03, not started)”

Ryan has an SC2 and wants a live capture. The Android phone has one USB port, which the SC2 occupies, so adb must run over the network (home Wi-Fi, not the drone’s).

  • Network adb: either adb tcpip 5555 once while the phone is on USB, then adb connect <phone-ip>:5555 and unplug (lasts until reboot), or Android 12 Wireless debugging with a pairing code (adb pair, then adb connect; this adb has no mDNS, so ports are typed by hand). Pin every command to the network serial. The phone was last seen at 192.168.1.201 and does not answer now (unplugged).
  • What a non-root phone can show: app logs (logcat: UsbAccessoryMux, ARDiscovery, ARNetworkAL, ARStream2) and the app’s own controller recorder. BlackboxRecorder opens a MppBlackBoxManager on the USB mux and records the controller’s piloting info (pitch, roll, yaw, gaz) plus a header with the remote controller’s serial, software version and hardware version and type. That would answer what firmware the SC2 runs (the “v0.9.1” label question). Not run; where the file lands is unchecked. The serial is private: do not publish it.
  • What it cannot show: raw mux bytes. Android exposes no usbmon, so that needs root or instrumentation on the phone, or a hardware USB tap. Not available.
  • Hazards to settle first:
    1. The SC2 may be in use by the pinephone session (goggle viewer). Asked.
    2. Keep the Bebop powered off for the first capture. With a drone present the app replays its saved settings through the controller (it would write max distance 2000 m over the current 150 m), and a second ARSDK handshake steals telemetry from whoever is flying. Any drone session needs bebop-main first and a settings read before and after.
    3. Charge the phone first: with the SC2 on its only port it cannot charge.
    4. Ownership of the Ulefone is still unconfirmed.

From the pinephone session (2026-10-03): the SC2 is free, and what it knows

Section titled “From the pinephone session (2026-10-03): the SC2 is free, and what it knows”

Secondhand: I have read its note’s headings and key lines, not re-derived them. The authority is skycontroller2-video.md, where each line is source-tagged. Reported there:

  • SC2 is the USB host, the phone the device. On Android it presents as an Open Accessory (manufacturer Parrot, model Skycontroller 2 or 2P); after the switch the phone enumerates as Google 18D1:2D00 / 2D01. Matches what the app’s accessory filter and aoad already told us.
  • libmux protocol v2 channels (from Parrot’s source): 1 transport (ARNetworkAL), 2 discovery, 3 backend (the JSON connect request that would otherwise go to TCP 44444), 4 stream data, 5 stream control, 6 RTP. This fills part of the earlier “mux format not established” gap and agrees with the app’s separate stream and control mux setup. ARDiscovery product ids: SC2 0x090f, SC2P 0x0915.
  • Measured with a plain USB-network gadget (no accessory mode) in the SC2: it enumerated the device, raised a network interface and leased 172.16.42.2 by DHCP. TCP 21, 7711 and 9050 open; 22, 23, 80, 554, 5555, 8080 closed; 44444 not probed. GET http://172.16.42.2:7711/video returned a 75-byte SDP-like body naming H.264 RTP on port 55004; no RTP followed (drone state unrecorded). A forum source says the SC2 serves video over HTTP on 7711 to a USB-Ethernet device.
  • Worth flagging: adb on 9050 was open on the SC2 in that state. Our image analysis says adbd starts only when ro.debuggable=1. Either that unit runs something other than the rc3 image or its properties differ, which also bears on the unread firmware version. Unauthenticated adb on a controller is a security note, and nothing was done with it.
  • Open question on their side: whether emulating the accessory on a Linux phone is worth attempting. A capture of the libmux handshake or the accessory control transfers would answer it. Our non-root phone can show app logs and the app’s recorder but not those raw bytes (see the plan above), so say so before promising.

Comments

Spotted a mistake, or tried this on your own Bebop? Leave a note. Comments are kept on this site's own server.