Questions about the FP (Open) OS development process

After looking around on the forum and documentation for a while, some questions about the FP OS development presented itself, which I listed below. For some questions I found or deduced some answers, which I included, but would be good to confirm or correct. Overall, I think the answers to these questions would be good to have readily available for new users.

I realize that these questions (and more so the implied suggestions) should probably be directed at the Fairphone company, but asking the community seems like a good starting point (and perhaps FP reads along as well).

  1. What is the difference between FP closed and FP Open?
    • Open is only open-source (except for device drivers),
      so it lacks the Google applications and services.
    • Open is easier to root.
    • Open ships with the TWRP recovery instead of the Android default
      recovery image.
    • Open releases happen later than closed releases, and
      the source code for Open releases is sometimes released even
      later than the binary release?
    • Version numbers are different. Open uses e.g. 17.04.1, meaning
      year 2017, month april, first release, while closed uses e.g.
      1.13.0 (not sure if there is any meaning to that). Looking at
      the version numbers for the closed Marshmellow (beta) releases, this
      seems to switch to to the same 17.04.1 versioning scheme. Right
      now, this means that there are open versions of Lollipop and
      closed versions of Marshmellow that have the same version
      number, which seems confusing. Hopefully these will sync up once
      the open version is updated to Marshmellow too?
    • Any other differences?
  2. Are closed and Open OS built from a common codebase? Are the open
    parts of the closed OS available?
    • I would expect that they build from the
      same tree, with the closed version having some extra software / apks
      that are included during the build. If you add the extra bits and
      set the “closed” flag during the build, you get the closed
      version, if you set the “open” flag, you get the FP Open version.
    • There are some indications (differences in release timing, lack of
      source code for the closed version, seemingly unrelated version
      numbers) that make me suspect that this process is different, and
      these OS versions are completely unrelated, with fixes and changes
      being manually ported over. Without knowing details, this sounds
      like extra work, resulting in extra frustration for users. Am I
      missing reasons for doing this anyway?
    • From talking to Fairphone devs, I’ve learned that originally there
      were separate build trees, with the closed tree being partly
      developed by a third party, and changes being copied into the
      open version later. AFAIU Fairphone has worked hard to pull most
      of the development in-house, making them less dependent on
      external parties. Also, this allows to merge the open and closed
      trees in the future, so the open bits can be shared between both
      versions, simplifying development and eventually perhaps
      developing / releasing the open version before the closed version.
  3. Why does switching between FPOS and FP Open erase all data? If it’s
    just the same OS but with more or less closed bits, shouldn’t the
    data and upgrade process be compatible?
    • According to one Fairphone dev, most bits would be compatible, but
      some apps end up crashing and it seems generally hard to guarantee
      compatibility, so all data is cleared to be sure it works.
  4. Can all Fairphone-specific code be browsed somewhere? The instructions only talk about using the repo tool
    to clone and build, but having browser-based access greatly reduces
    the barrier for looking through the source code.
    • Through some URL-guessing I found
      with gitweb references, but that would be good to have more
      prominently advertised.
    • This list does have a lot of fp2-dev/device/ repositories, which
      seem like they’re just the upstream version, with no FP-specific
      changes and it looks like they wouldn’t be needed for FP anyway.
      Why are they here?
  5. Is there any way to follow development? Such as a public bugtracker,
    or commit history?
    • From what I’ve read, most development happens on the closed OS,
      without any public record of what is happening. Only after a
      release, the relevant bits are ported over to the open OS and
      thus published in one go.
      See above about merging the two
      development trees.
    • Just after I posted this, a public bugtracker was announced for
      the Marshmellow-based OS versions. @Douwe confirmed that this will
      be the primary bugtracker used by the Fairphone team as well,
      which is a great step!

ad Q1) More differences:

  • Open OS is rooted by default
  • Open OS comes with TWRP

ad Q2) Common codebase?

FP OS updates come first as they are developed, then sent to G%&$e for approval and then the work on the Open OS version of that update starts. So yes, it’s the same code base. The lack of public source code for the closed source version is simply because it’s closed source.

ad Q3) why is data erased when switching?

I’m sure there are better explanations but one guess: to make sure you really get rid of everything G%&$e.

  • PS: I just tested by mistake. I switched from FP OS to MM beta, then to FP Open and back to FP OS and haven’t lost any data or apps.

ad Q4)

A #bugtracker for Android 6 beta exists and will probably be used for closed and open OS in the future.

4 posts were split to a new topic: Is wiping data necessary when switching OSes?

This topic was automatically closed 182 days after the last reply. New replies are no longer allowed.