Android 14 foreground service type required

android/hello_sdl_android/src/main/AndroidManifest.xml

@@ -8,6 +8,8 @@
         tools:targetApi="31"/>
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS"
         tools:targetApi="33"/>
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_CONNECTED_DEVICE"
+        tools:targetApi="34"/>
     <uses-permission android:name="android.permission.INTERNET" />
     <!-- Required to check if WiFi is enabled -->
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

android/hello_sdl_android/src/main/java/com/sdl/hellosdlandroid/SdlReceiver.java

@@ -1,18 +1,28 @@
 package com.sdl.hellosdlandroid;
 
 import android.app.PendingIntent;
+import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
+import android.content.IntentFilter;
+import android.hardware.usb.UsbAccessory;
+import android.hardware.usb.UsbManager;
 import android.os.Build;
 
 import com.smartdevicelink.transport.SdlBroadcastReceiver;
 import com.smartdevicelink.transport.SdlRouterService;
 import com.smartdevicelink.transport.TransportConstants;
+import com.smartdevicelink.util.AndroidTools;
 import com.smartdevicelink.util.DebugTool;
 
 public class SdlReceiver extends SdlBroadcastReceiver {
     private static final String TAG = "SdlBroadcastReceiver";
 
+    private static final String ACTION_USB_PERMISSION = "com.android.example.USB_PERMISSION";
+    private PendingIntent pendingIntent;
+    private Context storedContext;
+    private Intent storedIntent;
+
     @Override
     public void onSdlEnabled(Context context, Intent intent) {
         DebugTool.logInfo(TAG, "SDL Enabled");
@@ -24,6 +34,16 @@ public void onSdlEnabled(Context context, Intent intent) {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
             PendingIntent pendingIntent = (PendingIntent) intent.getParcelableExtra(TransportConstants.PENDING_INTENT_EXTRA);
             if (pendingIntent != null) {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+                    if (!AndroidTools.ServicePermissionUtil.hasForegroundServiceTypePermission(context)) {
+                        requestUsbAccessory(context);
+                        storedIntent = intent;
+                        storedContext = context;
+                        this.pendingIntent = pendingIntent;
+                        DebugTool.logInfo(TAG, "Permission missing for ForegroundServiceType connected device." + context);
+                        return;
+                    }
+                }
                 try {
                     pendingIntent.send(context, 0, intent);
                 } catch (PendingIntent.CanceledException e) {
@@ -56,4 +76,43 @@ public void onReceive(Context context, Intent intent) {
     public String getSdlServiceName() {
         return SdlService.class.getSimpleName();
     }
+
+    private final BroadcastReceiver mUsbReceiver = new BroadcastReceiver() {
+
+        public void onReceive(Context context, Intent intent) {
+            String action = intent.getAction();
+            if (ACTION_USB_PERMISSION.equals(action) && storedContext != null && storedIntent != null && pendingIntent != null) {
+                if (AndroidTools.ServicePermissionUtil.hasForegroundServiceTypePermission(storedContext)) {
+                    try {
+                        pendingIntent.send(storedContext, 0, storedIntent);
+                    } catch (PendingIntent.CanceledException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+        }
+    };
+
+    /**
+     * Request permission from USB Accessory if USB accessory is not null.
+     * If the user has not granted the BLUETOOTH_CONNECT permission,
+     * we can request the USB Accessory permission to satisfy the requirements for
+     * FOREGROUND_SERVICE_CONNECTED_DEVICE and can start our service and allow
+     * it to enter the foreground. FOREGROUND_SERVICE_CONNECTED_DEVICE is a requirement
+     * in Android 14
+     */
+    private void requestUsbAccessory(Context context) {
+        UsbManager manager = (UsbManager) context.getSystemService(Context.USB_SERVICE);
+        if (manager.getAccessoryList() == null) {
+            return;
+        }
+        PendingIntent mPermissionIntent = PendingIntent.getBroadcast(context, 0, new Intent(ACTION_USB_PERMISSION), PendingIntent.FLAG_IMMUTABLE);
+        IntentFilter filter = new IntentFilter(ACTION_USB_PERMISSION);
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+            context.registerReceiver(mUsbReceiver, filter, Context.RECEIVER_EXPORTED);
+        }
+        for (final UsbAccessory usbAccessory : manager.getAccessoryList()) {
+            manager.requestPermission(usbAccessory, mPermissionIntent);
+        }
+    }
 }

android/hello_sdl_android/src/main/java/com/sdl/hellosdlandroid/SdlService.java

@@ -102,18 +102,25 @@ public void onCreate() {
     @SuppressLint("NewApi")
     public void enterForeground() {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            NotificationChannel channel = new NotificationChannel(BuildConfig.SDL_APP_ID, "SdlService", NotificationManager.IMPORTANCE_DEFAULT);
-            NotificationManager notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
-            if (notificationManager != null) {
-                notificationManager.createNotificationChannel(channel);
-                Notification.Builder builder = new Notification.Builder(this, channel.getId())
-                        .setContentTitle("Connected through SDL")
-                        .setSmallIcon(R.drawable.ic_sdl);
-                if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-                    builder.setForegroundServiceBehavior(Notification.FOREGROUND_SERVICE_IMMEDIATE);
+            try {
+                NotificationChannel channel = new NotificationChannel(BuildConfig.SDL_APP_ID, "SdlService", NotificationManager.IMPORTANCE_DEFAULT);
+                NotificationManager notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
+                if (notificationManager != null) {
+                    notificationManager.createNotificationChannel(channel);
+                    Notification.Builder builder = new Notification.Builder(this, channel.getId())
+                            .setContentTitle("Connected through SDL")
+                            .setSmallIcon(R.drawable.ic_sdl);
+                    if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                        builder.setForegroundServiceBehavior(Notification.FOREGROUND_SERVICE_IMMEDIATE);
+                    }
+                    Notification serviceNotification = builder.build();
+                    startForeground(FOREGROUND_SERVICE_ID, serviceNotification);
                 }
-                Notification serviceNotification = builder.build();
-                startForeground(FOREGROUND_SERVICE_ID, serviceNotification);
+            } catch (Exception e) {
+                // This should only catch for TCP connections on Android 14+ due to needing
+                // permissions for ForegroundServiceType ConnectedDevice that don't make sense for
+                // a TCP connection
+                DebugTool.logError(TAG, "Unable to start service in foreground", e);
             }
         }
     }

android/sdl_android/src/main/java/com/smartdevicelink/transport/SdlRouterService.java

@@ -862,6 +862,14 @@ public void handleMessage(Message msg) {
                     ParcelFileDescriptor parcelFileDescriptor = (ParcelFileDescriptor) msg.obj;
 
                     if (parcelFileDescriptor != null) {
+                        // Added requirements with Android 14, Checking if we have proper permission to enter the foreground for Foreground service type connectedDevice.
+                        // If we do not have permission to enter the Foreground, we pass off hosting the RouterService to another app.
+                        if (!AndroidTools.ServicePermissionUtil.hasForegroundServiceTypePermission(service.getApplicationContext())) {
+                            service.deployNextRouterService(parcelFileDescriptor);
+                            closeUSBAccessoryAttachmentActivity(msg);
+                            return;
+                        }
+
                         //New USB constructor with PFD
                         service.usbTransport = new MultiplexUsbTransport(parcelFileDescriptor, service.usbHandler, msg.getData());
 
@@ -900,16 +908,7 @@ public void onReceive(Context context, Intent intent) {
 
 
                     }
-
-                    if (msg.replyTo != null) {
-                        Message message = Message.obtain();
-                        message.what = TransportConstants.ROUTER_USB_ACC_RECEIVED;
-                        try {
-                            msg.replyTo.send(message);
-                        } catch (RemoteException e) {
-                            e.printStackTrace();
-                        }
-                    }
+                    closeUSBAccessoryAttachmentActivity(msg);
 
                     break;
                 case TransportConstants.ALT_TRANSPORT_CONNECTED:
@@ -919,6 +918,18 @@ public void onReceive(Context context, Intent intent) {
                     break;
             }
         }
+
+        private void closeUSBAccessoryAttachmentActivity(Message msg) {
+            if (msg.replyTo != null) {
+                Message message = Message.obtain();
+                message.what = TransportConstants.ROUTER_USB_ACC_RECEIVED;
+                try {
+                    msg.replyTo.send(message);
+                } catch (RemoteException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
     }
 
     /* **************************************************************************************************************************************
@@ -1166,7 +1177,7 @@ public void onCreate() {
     /**
      * The method will attempt to start up the next router service in line based on the sorting criteria of best router service.
      */
-    protected void deployNextRouterService() {
+    protected void deployNextRouterService(ParcelFileDescriptor usbPfd) {
         List<SdlAppInfo> sdlAppInfoList = AndroidTools.querySdlAppInfo(getApplicationContext(), new SdlAppInfo.BestRouterComparator(), null);
         if (sdlAppInfoList != null && !sdlAppInfoList.isEmpty()) {
             ComponentName name = new ComponentName(this, this.getClass());
@@ -1178,11 +1189,25 @@ protected void deployNextRouterService() {
                     SdlAppInfo nextUp = sdlAppInfoList.get(i + 1);
                     Intent serviceIntent = new Intent();
                     serviceIntent.setComponent(nextUp.getRouterServiceComponentName());
+                    if (usbPfd != null) {
+                        serviceIntent.setAction(TransportConstants.BIND_REQUEST_TYPE_ALT_TRANSPORT);
+                        serviceIntent.putExtra(TransportConstants.CONNECTION_TYPE_EXTRA, TransportConstants.AOA_USB);
+                        serviceIntent.putExtra(FOREGROUND_EXTRA, true);
+                    }
                     if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
                         startService(serviceIntent);
                     } else {
                         try {
                             startForegroundService(serviceIntent);
+                            if (usbPfd != null) {
+                                UsbTransferProvider usbTransferProvider = new UsbTransferProvider(getApplicationContext(), nextUp.getRouterServiceComponentName(), usbPfd, new UsbTransferProvider.UsbTransferCallback() {
+                                    @Override
+                                    public void onUsbTransferUpdate(boolean success) {
+                                        closeSelf();
+                                    }
+                                });
+                            }
+
                         } catch (Exception e) {
                             DebugTool.logError(TAG, "Unable to start next SDL router service. " + e.getMessage());
                         }
@@ -1282,7 +1307,7 @@ public int onStartCommand(Intent intent, int flags, int startId) {
         if (firstStart) {
             firstStart = false;
             if (!initCheck(isConnectedOverUSB)) { // Run checks on process and permissions
-                deployNextRouterService();
+                deployNextRouterService(null);
                 closeSelf();
                 return START_REDELIVER_INTENT;
             }

android/sdl_android/src/main/java/com/smartdevicelink/transport/UsbTransferProvider.java

@@ -40,6 +40,7 @@
 import android.content.ServiceConnection;
 import android.hardware.usb.UsbAccessory;
 import android.hardware.usb.UsbManager;
+import android.os.Build;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.IBinder;
@@ -130,6 +131,26 @@ public UsbTransferProvider(Context context, ComponentName service, UsbAccessory
 
     }
 
+    public UsbTransferProvider(Context context, ComponentName service, ParcelFileDescriptor usbPfd, UsbTransferCallback callback) {
+        if (context == null || service == null || usbPfd == null) {
+            throw new IllegalStateException("Supplied params are not correct. Context == null? " + (context == null) + " ComponentName == null? " + (service == null) + " Usb PFD == null? " + usbPfd);
+        }
+        if (usbPfd.getFileDescriptor() != null && usbPfd.getFileDescriptor().valid()) {
+            this.context = context;
+            this.routerService = service;
+            this.callback = callback;
+            this.clientMessenger = new Messenger(new ClientHandler(this));
+            this.usbPfd = usbPfd;
+            checkIsConnected();
+        } else {
+            DebugTool.logError(TAG, "Unable to open accessory");
+            clientMessenger = null;
+            if (callback != null) {
+                callback.onUsbTransferUpdate(false);
+            }
+        }
+    }
+
     @SuppressLint("NewApi")
     private ParcelFileDescriptor getFileDescriptor(UsbAccessory accessory, Context context) {
         if (AndroidTools.isUSBCableConnected(context)) {
@@ -173,7 +194,12 @@ private boolean bindToService() {
         Intent bindingIntent = new Intent();
         bindingIntent.setClassName(this.routerService.getPackageName(), this.routerService.getClassName());//This sets an explicit intent
         //Quickly make sure it's just up and running
-        context.startService(bindingIntent);
+        bindingIntent.setAction(TransportConstants.BIND_REQUEST_TYPE_ALT_TRANSPORT);
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+            context.startService(bindingIntent);
+        } else {
+            context.startForegroundService(bindingIntent);
+        }
         bindingIntent.setAction(TransportConstants.BIND_REQUEST_TYPE_USB_PROVIDER);
         return context.bindService(bindingIntent, routerConnection, Context.BIND_AUTO_CREATE);
     }

android/sdl_android/src/main/java/com/smartdevicelink/util/AndroidTools.java

@@ -32,6 +32,7 @@
 
 package com.smartdevicelink.util;
 
+import android.Manifest;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
@@ -47,10 +48,13 @@
 import android.content.res.XmlResourceParser;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
+import android.hardware.usb.UsbAccessory;
+import android.hardware.usb.UsbManager;
 import android.os.BatteryManager;
 import android.os.Build;
 import android.os.Bundle;
 import androidx.annotation.Nullable;
+import androidx.core.content.ContextCompat;
 
 import com.smartdevicelink.marshal.JsonRPCMarshaller;
 import com.smartdevicelink.proxy.rpc.VehicleType;
@@ -392,4 +396,31 @@ public static void saveVehicleType(Context context, VehicleType vehicleType, Str
             return null;
         }
     }
+
+    public static class ServicePermissionUtil {
+        public static boolean hasUsbAccessoryPermission(Context context) {
+            UsbManager manager = (UsbManager) context.getSystemService(Context.USB_SERVICE);
+            if (manager == null || manager.getAccessoryList() == null) {
+                return false;
+            }
+            for (final UsbAccessory usbAccessory : manager.getAccessoryList()) {
+                if (manager.hasPermission(usbAccessory)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public static boolean checkPermission(Context applicationContext, String permission) {
+            return PackageManager.PERMISSION_GRANTED == ContextCompat.checkSelfPermission(applicationContext, permission);
+        }
+
+        public static boolean hasForegroundServiceTypePermission(Context context) {
+            // if Build is less than Android 14, we don't need either permission to enter the foreground.
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+                return true;
+            }
+            return ServicePermissionUtil.checkPermission(context, Manifest.permission.BLUETOOTH_CONNECT) || ServicePermissionUtil.hasUsbAccessoryPermission(context);
+        }
+    }
 }