DEV Community: Sam (NBTX)

Install Windows 11 (UEFI) via USB 3.0 Drive

Sam (NBTX) — Wed, 08 Jun 2022 18:45:03 +0000

This article is imported from my blog. Please let me know if there are any issues (broken links or grammatical errors due to missing characters) by commenting on this article.

Installing Windows 11 in UEFI mode from a USB 3.0 drive proves to be rather painful but luckily sticking together a few different workarounds for various issues sourced from all over the internet makes it possible - though rather convoluted...

Problem 1: Creating the bootable USB drive: FAT32 File System limit

Right off the bat, creating the drive manually instantly presents a problem; the Windows Imaging file for installation, install.wim is too large (> 4GiB) for the FAT32 partition that the installation media boots from so a direct image cannot be made.

Therefore, the image file needs to be split up into multiple split .wim files (SWMs). On macOS this can be done with wimlib as follows (for other systems there are undoubtably guides available and on Windows the Media Creation tool can presumably be used):

See below for an explanation.

open windows.iso # Replace windows.iso with the name of the installation ISO.
cd /Volumes/CCCOMA_X64FRE_EN-US_DV9 # Replace with the name of the mounted volume from the ISO.
rsync -avh --progress --exclude=sources/install.wim /Volumes/CCCOMA_X64FRE_EN-US_DV9/ /Volumes/WINDOWS

# If you don't already have it installed, you will need to install wimlib with `brew install wimlib`
wimlib-imagex split /Volumes/CCCOMA_X64FRE_EN-US_DV9/sources/install.wim /Volumes/WINDOWS/sources/install.swm 3800

sudo diskutil unmountDisk /Volumes/WINDOWS
sudo diskutil unmountDisk /Volumes/CCCOMA_X64FRE_EN-US_DV9

Format your USB drive to have a FAT32 partition with GPT (GUID Partition Table) in Disk Utility. This guide assumes you named the drive WINDOWS.
Mount the Windows Installation ISO with open windows.iso in a Terminal window, where windows.iso is the Windows Installation ISO downloaded from Microsoft.
Using Terminal, switch to the mounted ISO, which will be something like /Volumes/CCCOMA_X64FRE_EN-US_DV9 (ls /Volumes will allow you to check, but this guide will assume the aforementioned name).
Copy the contents of the Windows Installation ISO (excluding the install.wim file to the USB drive): rsync -avh --progress --exclude=sources/install.wim /Volumes/CCCOMA_X64FRE_EN-US_DV9/ /Volumes/WINDOWS
Install wimlib with Homebrew - a tool used to split the WIM file: brew install wimlib
Split the image with wimlib (this should yield two files, named similarly to install.wim and install1.wim on the USB drive): wimlib-imagex split /Volumes/CCCOMA_X64FRE_EN-US_DV9/sources/install.wim /Volumes/WINDOWS/sources/install.swm 3800
Finally unmount both the USB drive and the ISO file: sudo diskutil unmountDisk /Volumes/WINDOWS and sudo diskutil unmountDisk /Volumes/CCCOMA_X64FRE_EN-US_DV9

...and with that you're ready to begin attempting to install Windows.

Problem 2: Installing Windows from the USB drive

With this done, I encountered another issue - USB 3.0 flash drives seem to cause problems with the Windows Setup wizard's checks as to whether Windows can be installed despite selection of a valid partition. (Presumably because Windows is unable to tell if a partition/volume belongs to a removable drive or not without the necessary drivers.)

I eventually managed to workaround this issue by performing installation manually with the DISM (Deployment Image Servicing and Management) tool included in the Windows Installation media.

Boot your Windows Installation Media in UEFI mode, enter your language and region settings and click 'Install Windows'.
Remove all the partitions on the target drive and click 'New' to create a new partition to install Windows. (Or, alternatively, tweak as desired ensuring that there is a FAT32 EFI system partition of at least 128MiB and an NTFS Windows installation partition of at least 52 GiB.)
If you are able to select the Windows installation partition and click 'Next', do so and complete setup normally. Otherwise, continue following this section.

2.1: Mounting the target installation disk

Press Shift + F10 to open a Command Prompt window and enter diskpart.
Identify the target disk to install Windows onto with list disk
Select the target disk with sel disk 0 (where 0 is the disk number from list disk).
Identify the partition numbers on the target disk with list part.
Select the EFI boot partition (FAT32-formatted and 128MiB in size) with sel part 1 (where 1 is the partition number from list part).
Assign the letter S: with assign letter=s.
Select the Windows installation partition (NTFS formatted and at least 52GiB in size) with sel part 3 (where 3 is the partition number from list part).
Assign the letter W: with assign letter=w.
Exit diskpart with exit

2.2: Installing Windows with DISM (Deployment Image Servicing and Management)

List the editions contained on the Windows Installation USB with dism and identify the index of the edition you wish to install:

dism /Get-WimInfo /WimFile:X:\sources\install.swm

Perform the Windows installation by applying the install*.swm image(s) with dism (where X:\ is the Windows Installation USB and where the /Index - in this case 4 is the edition index identified from before):

dism /Apply-Image /ImageFile:X:\sources\install.swm /SWMFile:X:\sources\install*.swm /ApplyDir:W: /Index:4

Wait for the operation to finish. If this was successful you should see "The operation completed successfully." printed once the progress bar reaches 100%.
Add the boot files to the EFI boot partition and add a boot entry using bcdboot:

bcdboot W:\Windows /S S: /F ALL

Wait for the operation to finish. If this was successful you should see "Boot files successfully created."

...once you've completed the above you can close the Command Prompt window by typing exit, then click the close button on the installer and, again, click close (now on the Install/Repair screen) which should prompt you to say that continuing may cause the machine to reboot. Confirm this (and if the machine does not reboot, hold down the power button to shut down your machine and manually power it back on). As soon as the machine shuts down, remove the USB installation drive.

When the machine boots, you should be booted into your new Windows installation.

Problem 3: Activation

Even after all of the above, in my case I ended up with an 'S version' of Windows and the Activation section of Settings was both failing to load and missing the option to exit S mode.

Pressing Win + R and entering cmd launched a dialog that then allowed me to exit S mode.

After which, launching cmd and using the slmgr /ipk <product key> command, where <product key> is your Windows product activation key to manually install the product key, followed by restarting the machine allowed me to activate the machine.

Wrap up

It's unclear to me why exactly these complications have not been ironed out (perhaps with the exception of Problem 3) and hopefully they'll be fixed in future but I believe it's useful to have the steps noted down somewhere in case they're needed.

With the above, you should now have Windows 11 successfully installed and activated. If you notice any mistakes or oversights please be sure to leave a comment.

Sources

Automatically build your Flutter app APKs with Travis-CI

Sam (NBTX) — Thu, 20 Jun 2019 19:22:40 +0000

This article is imported from my blog. Please let me know if there are any issues (broken links or grammatical errors due to missing characters) by commenting on this article.

When attempting to setup Travis-CI, I saw more than a few articles on running Flutter tests with Travis, but none for actually building and obtaining a compiled APK as we wanted.

Whenever changes are pushed to the GitHub repository a new build is automatically generated by Travis and a link to the APK on WeTransfer is posted to a Discord channel for supporters and beta testers allowing them to comment on the new build.

In this article I'm going to comment on how we achieved this workflow, as well as giving some general advice.

Step 1: Create Travis Configuration

Start by creating the following directory structure. You only need to include the .travis/ directory (also in the root) if you plan to add additional build scripts to your project.

your_project_root/
    - .travis.yml
    - .travis/
        - utils/

In your .travis.yml you need to add some basic boilerplate configuration:I didnt set the language to Android because it didnt seem to setup the SDK correctly, plus using node as the language allowed us to easily set up additional build scripts.

os: linux

# The Ubuntu Trusty release on Travis is known to
# have oraclejdk8 available. For some reason, we couldn't
# get this to work with other distributions/releases.
dist: trusty
jdk: oraclejdk8

# We set language to Node.js (JavaScript) for the sake
# of making creating utility scripts later on easier.
language: node_js
node_js:
  - "12"

env:
  global:
    - ANDROID_SDK_ROOT=/opt/android

sudo: required

addons:
  apt:
    # Flutter depends on /usr/lib/x86_64-linux-gnu/libstdc++.so.6 version GLIBCXX_3.4.18
    sources:
      - ubuntu-toolchain-r-test # if we don't specify this, the libstdc++6 we get is the wrong version
    packages:
      - lib32stdc++6 # https://github.com/flutter/flutter/issues/6207
      - libstdc++6
      - curl

cache:
  directories:
    - $HOME/.pub-cache
    - node_modules

Next, we need to setup our initial before_script stage. This will execute commands to setup Gradle, the Android SDK and Flutter.

before_script:
  # Setup gradle.
  - wget https://services.gradle.org/distributions/gradle-4.10.3-bin.zip
  - unzip -qq gradle-4.10.3-bin.zip
  - export GRADLE_HOME=`pwd`/gradle-4.10.3
  - export PATH=$GRADLE_HOME/bin:$PATH

  # (Quick fix: Silence sdkmanager warning)
  - mkdir -p /home/travis/.android
  - echo 'count=0' > /home/travis/.android/repositories.cfg

  # Download and setup Android SDK tools.
  - wget https://dl.google.com/android/repository/sdk-tools-linux-4333796.zip
  - mkdir android-sdk-tools
  - unzip -qq sdk-tools-linux-4333796.zip -d android-sdk-tools
  - export PATH=`pwd`/android-sdk-tools/tools/bin:$PATH
  - mkdir -p $ANDROID_SDK_ROOT

  # This will install the Android SDK 28 using the previously installed SDK tools.
  - yes | sdkmanager --sdk_root=$ANDROID_SDK_ROOT "tools" "build-tools;28.0.3" "extras;android;m2repository" > /dev/null
  - export PATH=${ANDROID_SDK_ROOT}/tools/bin:$PATH

  # List sdkmanager packages
  # (useful when checking the logs)
  - sdkmanager --list

  # Clone Flutter
  # We clone the Flutter beta branch. You should clone whatever branch
  # you know works for building production apps.
  # If in doubt, you are advised to use the stable branch of Flutter
  # for production apps and you would do this by changing -b beta to -b stable
  # but we started the project before stable existed and whilst beta has always
  # worked reasonably well for us and we find stable is usually too outdated
  # and has too many missing framework features.
  - git clone https://github.com/flutter/flutter.git -b beta --depth 1

  # Add Flutter to the PATH environment variable.
  - export PATH=`pwd`/flutter/bin:`pwd`/flutter/bin/cache/dart-sdk/bin:$PATH

Finally, to get our fundamental configuration working, we of course have to actually execute flutter build. Which we do in the script stage.

script:
  # Prints the flutter version
  # (allows you to ensure, for each build, that Flutter is set up correctly.)
  - flutter doctor -v

  # Run Flutter build
  - ./flutter/bin/flutter build apk

Step 2: Upload the finished build to WeTransfer

Obviously, a key part of using Travis to build the compiled APK is being able to obtain the compiled APK. For this we use WeTransfer, a well-designed free (temporary) file sharing service with an API; exactly what we need.

Register an account for the WeTransfer Public API (developers.wetransfer.com) and under My apps , click Create new application. Enter your applications details and copy the API key.

Create an environment variable for your key. Go to the Travis page for your repository and click More options; in the dropdown choose Settings and under environment variables add a new environment variable called WT_API_KEY and paste in the key you copied previously. Do not enable the option to Display value in log file, this will expose your WeTransfer API key to anyone viewing your build logs.

after_success:
  # Export commit info
  - export AUTHOR_NAME=`git log -1 "$TRAVIS_COMMIT" --pretty="%aN"`
  - export COMMITTER_NAME=`git log -1 "$TRAVIS_COMMIT" --pretty="%cN"`
  - export COMMIT_SUBJECT=`git log -1 "$TRAVIS_COMMIT" --pretty="%s"`
  - export COMMIT_MESSAGE=`git log -1 "$TRAVIS_COMMIT" --pretty="%b"`
  # Upload to WeTransfer
  - npm install --save @wetransfer/js-sdk
  - export BUILD_OUTPUT_URL=`node ./.travis/utils/runUpload.js`

In order to give the file a clear name, we extract useful commit information from git (note; using the Travis commit reference.)

*$TRAVIS_COMMIT* is an automatic environment variable, exported by Travis at the start of a build. It refers to the git commit hash that is currently being built by Travis.

Then, we install the WeTransfer SDK using npm and call our own script:

const APPLICATION_NAME = "ApolloTV";

const fs = require('fs');
const createWTClient = require('@wetransfer/js-sdk');

const commit = process.env.TRAVIS_COMMIT.substring(0, 6);
const jobName = process.env.TRAVIS_JOB_NUMBER;
const buildName = process.env.TRAVIS_BUILD_NUMBER;
const title = process.env.COMMIT_SUBJECT;
const author = process.env.AUTHOR_NAME;
const message = `Job: ${jobName}, Build: ${buildName}\n\n${title} (${author})`;

(async function(){
  const wtClient = await createWTClient(process.env.WT_API_KEY, {
    logger: {
      level: 'error'
    }
  });

  const appBinaryContent = await new Promise((resolve, reject) => {
    fs.readFile(
      './build/app/outputs/apk/release/app-release.apk',
      (error, data) => {
        if(error) return reject(error);
        resolve(data);
      }
    );
  });

  const transfer = await wtClient.transfer.create({
    message: message,

    files: [
      {
        name: `${APPLICATION_NAME} Build ${buildName} - ${commit}.apk`,
        size: appBinaryContent.length,
        content: appBinaryContent,
      }
    ]
  });

  // This is required; this is so you can obtain the URL in your Travis/bash scripts.
  console.log(transfer.url);
})();

As you can see, it just uploads the file in the Flutter build output directory and prints the URL, from there youre ready to go with your compiled APK.

If you want to stop here, you can just echo the URL for the APK and then youre able to download the builds.

Step 3: Execute pre and post build web-hooks

We have web-hooks that send a message to a channel in our Discord server when a build has started or ended.

We find its pretty helpful to be alerted when a new build starts and finishes, however we also wanted to give our supporters access to cutting-edge builds as soon as theyre pushed to GitHub and we can use our web-hooks to notify supporters when a new build is starting as well as when it is finished and available to download.

before_install:
  # Execute Travis prebuild webhook.
  - ./.travis/10_prebuild.sh $WEBHOOK_URL

after_success:
  # Execute success procedure of postbuild webhook script.
  - ./.travis/40_postbuild.sh success $WEBHOOK_URL $BUILD_OUTPUT_URL

after_failure:
  # Execute failure procedure of postbuild webhook script.
  - ./.travis/40_postbuild.sh failure $WEBHOOK_URL

You may have noticed above that we have given numeric prefixes to each of our build scripts. This is because in our full configuration, we have further scripts to prepare our app build. This includes injecting a configuration into the app source code and checking translations.You can check out our actual build configuration on the Kamino GitHub repository.

In Discord, click the cog to edit a channel and then click Webhooks. Choose Create Webhook, give it a name such as Travis Build and copy the URL, then click Save.

In Travis, create an environment variable (see Step 2 for instructions on how to do this) for your web-hook URL. Again, do not enable display value in log file, this will allow anyone to send messages to your Discord channel with the web-hook.

Finally, you need to create the prebuild and postbuild scripts; these should go in the .travis folder in the root of your project (that you created in Step 1):

#!/bin/bash
TIMESTAMP=$(date -u +%FT%TZ)

AUTHOR_NAME="$(git log -1 "$TRAVIS_COMMIT" --pretty="%aN")"
COMMITTER_NAME="$(git log -1 "$TRAVIS_COMMIT" --pretty="%cN")"
COMMIT_SUBJECT="$(git log -1 "$TRAVIS_COMMIT" --pretty="%s")"
COMMIT_MESSAGE="$(git log -1 "$TRAVIS_COMMIT" --pretty="%b")"

WEBHOOK_DATA='{
    "username": "ApolloTV (Travis)",
    "content": "A build has started.\n\n[Job #'"$TRAVIS_JOB_NUMBER"' (Build #'"$TRAVIS_BUILD_NUMBER"') '"$STATUS_MESSAGE"' ('"$AUTHOR_NAME"') - '"$TRAVIS_REPO_SLUG"'\n\n'"$COMMIT_SUBJECT"']('"$TRAVIS_BUILD_WEB_URL"')"
}'

(curl --fail --progress-bar -H Content-Type:application/json -d "$WEBHOOK_DATA" "$1" \
&& echo -e "\\n[Webhook]: Successfully sent the webhook.") || echo -e "\\n[Webhook]: Unable to send webhook."

#!/bin/bash
STATUS="$1"

TIMESTAMP=$(date -u +%FT%TZ)

if ["$STATUS" = "success"]; then
    EMBED_COLOR=3066993
    STATUS_MESSAGE="Passed"
elif ["$STATUS" = "failure"]; then
    EMBED_COLOR=15158332
    STATUS_MESSAGE="Failed"
fi

WEBHOOK_DATA='{
  "username": "ApolloTV (Travis)",
  "content": "@BuildNotify A new build has completed",
  "embeds": [ {
    "color": '$EMBED_COLOR',
    "author": {
      "name": "Job #'"$TRAVIS_JOB_NUMBER"' (Build #'"$TRAVIS_BUILD_NUMBER"') '"$STATUS_MESSAGE"' - '"$TRAVIS_REPO_SLUG"'",
      "url": "'"$TRAVIS_BUILD_WEB_URL"'"
    },
    "title": "'"$COMMIT_SUBJECT"'",
    "url": "'"$URL"'",
    "description": " **Build Information** : '"${COMMIT_MESSAGE//$'\n'/ }"\\n\\n"$CREDITS"'",
    "fields": [
      {
        "name": "Commit",
        "value": "'"[${TRAVIS_COMMIT:0:7}](https://github.com/$TRAVIS_REPO_SLUG/commit/$TRAVIS_COMMIT)"'",
        "inline": true
      },
      {
        "name": "Branch",
        "value": "'"[$TRAVIS_BRANCH](https://github.com/$TRAVIS_REPO_SLUG/tree/$TRAVIS_BRANCH)"'",
        "inline": true
      },
      {
        "name": "Files",
        "value": "'"[Download APK]($BUILD_OUTPUT_URL)"'"
      }
    ],
    "timestamp": "'"$TIMESTAMP"'"
  } ]
}'

(curl --fail --progress-bar -H Content-Type:application/json -d "$WEBHOOK_DATA" "$2" \
&& echo -e "\\n[Webhook]: Successfully sent the webhook.") || echo -e "\\n[Webhook]: Unable to send webhook."

Feel free to use and customise these scripts as you wish.

Building an in-app updater (OTA) in Flutter

Sam (NBTX) — Mon, 25 Feb 2019 22:10:28 +0000

This article is imported from my blog. Please let me know if there are any issues (broken links or grammatical errors due to missing characters) by commenting on this article.

In many ways, Flutter is a fantastic framework for building cross-platform mobile applications however when it comes to developing features that arent platform-agnostic many people seem to resort to platform channel code.

I try to keep as much code as possible in Dart for three reasons:

It maintains the portability of my code base; should I need to implement a feature in another platform, I will have little to no code to rewrite.
It reduces the learning curve for our projects; developers only have to know Dart and they dont have to locate and interpret platform channel code.
Keep-it-simple-stupid (KISS) methodology; when you start messing around with platform channels you then have to worry about communicating between the Dart code and the platform code. This can get out of hand really quickly when you throw asynchronous operations into the mix.

So, as were focused on keeping our code in Dart, theoretically our main obstacles are that we need to work with files, system permissions and then we need to launch an intent. File support in Dart is actually not a problem and system permissions can be overcome with a handy plugin, however we did have to resort to platform channels for the intent, but thats about 10 lines of simple synchronous code.

Step 1: System Permissions

Thanks to a Flutter plugin called simple_permissions this wasn't much of an issue.

import 'package:simple_permissions/simple_permissions.dart';

// ...

bool permissionStatus = await SimplePermissions.checkPermission(Permission.WriteExternalStorage);
if(!permissionStatus) permissionStatus = (await SimplePermissions.requestPermission(Permission.WriteExternalStorage)) == PermissionStatus.authorized;

Remember to add the uses-permission tag to your AndroidManifest.xml

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

Step 2: Filesystem

Whilst theoretically a challenge because of the platform-agnostic nature of Flutter, between the built in dart:io library and the path-provider plugin, Flutter actually provides an excellent API for manipulating files.

import 'dart:io';
import 'package:path_provider/path_provider.dart';
import 'package:http/http.dart' as http;

// Don't forget to check that you have Filesystem permissions or this will fail!
class FileIO {

  static const downloadDirReference = "/.apollo";

  ///
  /// Download and install the app at [url]. 
  /// You should call this method *after* querying your server for any available updates
  /// and getting the download link for the update.
  ///
  static Future<void> runInstallProcedure(String url) async {

    / **************************************** /
    /* Setup and clean directories */
    / **************************************** /

    // Instantiate a directory object
    final downloadDir = new Directory(
      (await getExternalStorageDirectory()).path + downloadDirReference
    );

    // Create the directory if it doesn't already exist.
    if(!await downloadDir.exists()) await downloadDir.create();

    // Instantiate a file object (in this case update.apk within our download folder)
    final downloadFile = new File("${downloadDir.path}/update.apk");

    // Delete the file if it already exists.
    if(await downloadFile.exists()) await downloadFile.delete();

    / **************************************** /
    /* Download the APK */
    / **************************************** /

    // Instantiate an HTTP client
    http.Client client = new http.Client();

    // Make a request and get the response bytes.
    var req = await client.get(url); // (The link to your APK goes here)
    var bytes = req.bodyBytes;

    // Write the response bytes to our download file.
    await downloadFile.writeAsBytes(bytes);

    // TODO: Trigger intent.

  }

}

The key thing you probably noticed is that in Dart, you use theDirectory class to refer to a directory, and the File class to refer to a file; in my opinion, this is much more logical and aptly-named than it is in Java.

Everything is pretty self-explanatory and downloading files is an absolute breeze with Darts built in libraries.

NOTE: Android N support

Whilst nothing to do with Flutter, I've included this as it did take a bit of digging for me to get set up.

<manifest >
  <application>

    <!-- ... -->

    <provider
      android:name="xyz.apollotv.kamino.OTAFileProvider"
      android:authorities="xyz.apollotv.kamino.provider"
      android:exported="false"
      android:grantUriPermissions="true">

      <!-- The @xml/filepaths file (see below) is located at /android/app/src/main/res/xml/filepaths.xml
            relative to the Flutter project root. -->

      <meta-data
          android:name="android.support.FILE_PROVIDER_PATHS"
          android:resource="@xml/filepaths" />
    </provider>

  </application>
</manifest>

package xyz.apollotv.kamino;

import android.support.v4.content.FileProvider;

// You need to reference this FileProvider in your AndroidManifest.xml
public class OTAFileProvider extends FileProvider {}

<?xml version="1.0" encoding="utf-8"?>
<paths xmlns:android="http://schemas.android.com/apk/res/android">

    <!-- In our example, the APK is downloaded to the /storage/emulated/0/.apollo/ folder. -->
    <external-path name=".apollo" path=".apollo/"/>

</paths>

Inside your application tag in your Android manifest file, you should include a provider tag that references your File Provider class. Inside this tag, you should have a meta-data tag that lists all of the file paths the provider is allowed to access. (See filepaths.xml).

For more information about the FileProvider, see https://developer.android.com/reference/android/support/v4/content/FileProvider

Step 3: Platform Channel

The final step, is to launch an ACTION_INSTALL_PACKAGE intent. You should begin by setting up a basic platform channel.

OTAHelper.installOTA(downloadFile.path);


class OTAHelper {

  // Replace xyz.apollotv.kamino with your package.
  static const platform = const MethodChannel('xyz.apollotv.kamino/ota');

  static Future<void> installOTA(String path) async {
    try {
      await platform.invokeMethod('install', <String, dynamic>{
        "path": path
      });
    } on PlatformException catch (e) {
      print("Error installing update: $e");
    }
  }

}

Finally, edit your MainActivity.java file to declare the MethodChannel and execute the code to call our intent.

There arent any particularly advanced concepts here, as weve downloaded the file to external memory, so all we need to do is access it and trigger an installation.

public class MainActivity extends FlutterActivity {

  @Override
  protected void onCreate(Bundle savedInstanceState) {

    // ...

    new MethodChannel(getFlutterView(), "xyz.apollotv.kamino/ota").setMethodCallHandler((methodCall, result) -> {
        if(methodCall.method.equals("install")){
            if(installOTA(methodCall.argument("path"))){
                result.success(true);
            }else{
                result.error("ERROR", "An error occurred whilst installing OTA updates.", null);
            }
            return;
        }
        result.notImplemented();
    });

  }

  private boolean installOTA(String path){
      try {
          Uri fileUri = Uri.parse("file://" + path);

          Intent intent;
          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {

              // This line is important: after Android N, an authority must be provided to access files for an app.
              Uri apkUri = OTAFileProvider.getUriForFile(getApplicationContext(), "xyz.apollotv.kamino.provider", new File(path));

              intent = new Intent(Intent.ACTION_INSTALL_PACKAGE);
              intent.setData(apkUri);
              intent.setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
          } else {
              intent = new Intent(Intent.ACTION_VIEW);
              intent.setDataAndType(fileUri, "application/vnd.android.package-archive");
              intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
          }

          getApplicationContext().startActivity(intent);
          return true;
      }catch(Exception ex){
          System.out.println("[Platform] Error during OTA installation.");
          System.out.println(ex.getMessage());
          return false;
      }
  }

}

And with that, the OTA installation is started!