Android App Launch Service

APK

The application APK must follow the guidelines below to ensure a successful installation, launch, and operation.

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

val notificationIntent = Intent(this, QtActivity::class.java)
val pendingIntent = PendingIntent.getActivity(this, 0, notificationIntent, 0)

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
    val notification = Notification.Builder(this, CHANNEL_ID)
        .setContentTitle("forcevideo")
        .setSmallIcon(R.mipmap.ic_launcher)
        .setContentIntent(pendingIntent)
        .setPriority(Notification.PRIORITY_LOW)
        .setOnlyAlertOnce(true)
        .setSound(null, null)
        .build()
    context.startForeground(1, notification)
} else {
    val serviceIntent = Intent(context, YourService::class.java)
    context.startService(serviceIntent)
}

android {
    compileSdkVersion 27
    buildToolsVersion "28.0.3"
}
compileOptions {
    sourceCompatibility 1.8
    targetCompatibility 1.8
}
defaultConfig {
    minSdkVersion 19
    targetSdkVersion 27
    versionCode 1
    versionName "1.0"
}
lintOptions {
    abortOnError false
}

CKSUM

Checksum files must use the same name as the application's APK with the cksum file type.

# [cksum file name example](#cksum-file-name-example) {#cksum-file-name-example}
app_apk_name.cksum

CFG

The filename of the CFG file must be unique from the other app config files.

An example of a config file with the required minimum parameters:

{
    "apk": "games_app.apk",
    "launchintent": "com.abc.games.app",
    "obb": [],
    "pacinfobundle": 1
}

The CFG file can contain the following parameters:

• apk — Required

  Specifies the name of the application's APK.

  Example:

  {
      "apk": "SAMPLE.apk"
  }

• launchintent — Required

  Specifies the package name or package name and main activity passed to AppLaunchService to launch the application.

  Format: packageName or packageName/activityName

  If the ActivityName is not specified, AppLaunchService will query for the launch activity and use that instead.

  Example with ActivityName specified:

  json with just package { "launchintent": "com.dtisoft.games.candys" }

  json with package and activity { "launchintent": "com.dtisoft.games.candys/com.dtisoft.games.candys.ActivitiyName" }

• obb — Required

  Specifies the name of all OBBs that are associated with the application, if any. Set to an empty array if the application contains no OBBs.

  Example with no OBBs:

  {
      "obb": []
  }

  Example with one OBB:

  {
      "obb": ["SAMPLE.APP.obb"]
  }

  Example with multiple OBBs:

  {
      "obb": [
          "SAMPLE.APP1.obb",
          "SAMPLE.APP2.obb",
          "SAMPLE.APP3.obb"
      ]
  }

• pacinfobundle — Required

  Set this parameter to 1 if you want LRU and configuration information. Otherwise, set this to 0.

  If set to 1, refer to the PAC Information Bundle for LRU and configuration information.

• extras — Optional

  These are extra commands that AppLaunchService can send to the application.

  Example:

  {
      "extras": {
          "key1": "abc",
          "key2": 123
      }
  }

• receiver_action, receiver_name — Optional

  This is intended for core applications that need to run in the background.

  This allows preinstalled applications to run in the background as a service on bootup.

  • receiver_name — Represents the BroadcastReceiver that is listening for the action specified in receiver_action.

  • receiver_action — Represents the name of the action that the application's BroadcastReceiver is listening for.

  When an application is installed, it is in an "inactive" state. To start the application for the first time or during bootup, core services send an intent with the receiver action and name indicated in the configuration file. The receiver in your application can then start itself as a background service.

  • If the application is running on Android 8, BroadcastReceiver can call startForegroundService().

  • If the application is running on Android 5.1, BroadcastReceiver can call startService().

  Example:

  {
      "apk": "pacgames_pong",
      "launchintent": "com.pacgames.games.pong",
          "receiver_name": "aero.pac.simpletestapp3/aero.pac.simpletestapp3.MyReceiver",
      "receiver_action": "aero.panasonic.intent.action.test",
      "obb": [
          "pacgames_pong_resources.obb",
          "pacgames_graphicassets.obb"
      ],
      "pacinfobundle": 1
  }

• quit — Optional

  This is a command that AppLaunchService sends to quit the application.

  Example:

  {
      "quit": "SAMPLE.APP.quit"
  }

• DefaultInputMode — Optional

  Specifies how the D-pad is used in handsets while the app is active.

  Example:

  DefaultInputMode = { { 1, 4, 7, 8, 25 }, 0, 0, 0, 0, 0 };

  Format:

  DefaultInputMode = { { a, b, c, d, e }, f, g, h, i, j };

  The following values can be set:

  Element	Description
  a	Pointer modes. Values: 0 — iicore_handset_control_enum_keymap_mode_mouse 1 — iicore_handset_control_enum_keymap_mode_keyboard 2 — iicore_handset_control_enum_keymap_mode_point 5 — iicore_handset_control_enum_keymap_mode_dual_keypad
  b	Orientation modes. Values: 3 — horizontal 4 — vertical
  c	Handset key enable/disable modes. Values: 6 — iicore_handset_control_enum_keymap_mode_enable_key_to_mouse 7 — iicore_handset_control_enum_keymap_mode_disable_key_to_mouse
  d	Touchpad modes. Values: 8 — disable touchpad mouse 9 — enable touchpad mouse
  e	Next handset mode. Values: 25 — disable both sides of the Next handset 26 — disable the game side of the Next handset 27 — disable the non game side of the Next handset 28 — enable both sides of the Next handset
  f	Acceleration of the mouse mode pointer.
  g	Initial speed of the mouse mode pointer.
  h	Max speed of the mouse mode pointer in pixels per second.
  i	Enable or disable touch screen state. Values: 0 — enable 1 — disable
  j	Specify remote touch screen mode. Values: 0 — Touch screen: Requires absolute coordinates. 1 — Touchpad: Acts similar to a trackpad. 2 — Dual mode: Acts similar to a trackpad except when multiple fingers are interacting with the touch screen. 3 — D-pad mode: Recognizes up, down, left and right key events, depending on the swipe gesture.

OBB

Android Expansion files (OBB) are optional unless an Android application package size exceeds 100 MB. The default OBB file size is 2 GB.

An APK should package extra content in a main file and a patch OBB file. If more expansion files are needed, vendors can request support for additional OBB files.

• Main OBB files are recommended for applications that do not update assets frequently.

• Patch OBB files are recommended for applications with frequent updates.

Assign OBBs with the permission 666. OBBs must always be placed in the apps directory through an NBD content push.

Install an Application During Bootup Using NBD

Installing an application on bootup results in shorter application launch times. However, this approach increases the overall boot duration for AppLaunchService and requires careful management of system resources. Installing too many applications during bootup can lead to undesirable behavior, such as previously installed applications being uninstalled to make room for later application installations.

To install an application during seatback bootup:

• Register the APK, the checksum, the CFG, and the OBB, if available, with NBD. These must all have the cd_apk tag and storage set to client.

• In the /tmp/pluginshare/nbd/vfs/install_apps directory, push only the APK, CFG, and checksum files. Do not include any OBB files.

• All required OBBs must be pushed to /tmp/pluginshare/nbd/vfs/apps with the cd_apk tag and storage set to client.

To ensure an application gets preinstalled or is able to have its content updated during a flight, you must register all relevant files with the cd_apk tag and storage to client. This enables AppLaunchService to get information through PAC IO messages to process the pushed NBD files accordingly.

Install and Launch an Application On Demand

All files, which include the APK, the checksum, the CFG, and OBBs, if available, must be pushed to /tmp/pluginshare/nbd/vfs/apps.

Install

You can install single or multiple applications without launching the applications. You can also directly launch applications without installing beforehand because launching automatically installs the application.

Launch

val intent = Intent("aero.panasonic.intent.action.VFS_LAUNCH_APP").apply {
    component = ComponentName(“aero.panasonic.applaunchservice", "aero.panasonic.applaunchservice.VfsLaunchAppReceiver”)
    putExtra(launch_app", appName) 
    addFlags(Intent.FLAG_RECEIVER_FOREGROUND)
}

val bundle = Bundle()
intent.putExtra("extras", bundle)
context.sendBroadcast(intent)

val intent = Intent("aero.panasonic.intent.action.LAUNCH_APP").apply {
    component = ComponentName(“aero.panasonic.applaunchservice", "aero.panasonic.applaunchservice.AppLaunchReceiver")
    putExtra(launch_intent", appIntent); // appIntent is the intent to launch your application. 
    addFlags(Intent.FLAG_RECEIVER_FOREGROUND)
}
sendBroadcast(intent);

Get Status Updates

To receive status updates, create an intent as follows:

• action: "aero.panasonic.intent.action.VFS_LAUNCH_APP_STATUS"

• package: "aero.panasonic.applaunchservice"

• extra: "return_code", integer value

  Create return_code variables and set to the following integer values:

  return_code variable	Set to
  ERROR_CANT_CREATE_LINK	-2
  ERROR_OBB_FILE_NOT_FOUND	-3
  ERROR_CONFIG_FILE	-4
  ERROR_TIMEOUT	-10
  ERROR_CODE_NOT_RETURNED	-999
  RETURN_CODE_INSTALLING	-50
  ERROR_NO_LAUNCH_INTENT_FOR_PACKAGE	-51
  RETURN_CODE_INSTALLATION_DONE	-52
  RETURN_CODE_LAUNCH_CANCELED	-60
  RETURN_CODE_LAUNCHING	-100

package_name and launch_app will be returned as extras with the package name and application's root CFG filename for the following status return_code variables:

• RETURN_CODE_INSTALLING

• RETURN_CODE_INSTALLATION_DONE

• RETURN_CODE_LAUNCHING

• RETURN_CODE_LAUNCH_CANCELED

Uninstall

You can uninstall a single application or all applications at the same time.

When the application is uninstalled, listen for the android.intent.action.PACKAGE_REMOVED action, which signals the action for Android package removal.

val intent = Intent("aero.panasonic.intent.action.VFS_REMOVE_ALL").apply {
    component = ComponentName(“aero.panasonic.applaunchservice", "aero.panasonic.applaunchservice.UninstallReceiver")
    addFlags(Intent.FLAG_RECEIVER_FOREGROUND)
    addFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES)
}
sendBroadcast(intent);

Clear User Data

You can clear user data from an application. Android will force the application to stop after data is cleared.

Create an intent as follows:

• action: "aero.panasonic.intent.action.CLEAR_USER_DATA"

• component: "aero.panasonic.applaunchservice/aero.panasonic.applaunchservice.UninstallReceiver"

• extra: "package_list", StringArrayList of package names to clear user data

Cancel Pending Launch

You can stop an application from launching if it's in the process of being installed but has not been launched.

An example of this situation is when a pending application is trying to launch but must be canceled from launching due to a closed flight event.

Create an intent as follows:

• action: "aero.panasonic.intent.action.VFS_CANCEL_LAUNCH_APP"

• package: “aero.panasonic.applaunchservice”

val intent = Intent("aero.panasonic.intent.action.VFS_CANCEL_LAUNCH_APP").apply {
    setPackage(“aero.panasonic.applaunchservice”)
    addFlags(Intent.FLAG_RECEIVER_FOREGROUND)
    addFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES)
}