| /* |
| * Copyright (C) 2015 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.tv.tuner; |
| |
| import android.app.AlarmManager; |
| import android.app.Notification; |
| import android.app.NotificationChannel; |
| import android.app.NotificationManager; |
| import android.app.PendingIntent; |
| import android.content.BroadcastReceiver; |
| import android.content.ComponentName; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.SharedPreferences; |
| import android.content.pm.PackageManager; |
| import android.content.pm.PackageManager.NameNotFoundException; |
| import android.graphics.Bitmap; |
| import android.graphics.BitmapFactory; |
| import android.hardware.usb.UsbDevice; |
| import android.hardware.usb.UsbManager; |
| import android.net.ConnectivityManager; |
| import android.net.NetworkInfo; |
| import android.net.Uri; |
| import android.os.AsyncTask; |
| import android.os.Handler; |
| import android.os.Looper; |
| import android.os.Message; |
| import android.os.SystemClock; |
| import android.preference.PreferenceManager; |
| import android.support.annotation.NonNull; |
| import android.text.TextUtils; |
| import android.util.Log; |
| import android.widget.Toast; |
| import com.android.tv.R; |
| import com.android.tv.Starter; |
| import com.android.tv.TvApplication; |
| import com.android.tv.TvSingletons; |
| import com.android.tv.common.BuildConfig; |
| import com.android.tv.common.util.SystemPropertiesProxy; |
| |
| |
| import com.android.tv.tuner.setup.BaseTunerSetupActivity; |
| import com.android.tv.tuner.util.TunerInputInfoUtils; |
| import java.text.ParseException; |
| import java.text.SimpleDateFormat; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.concurrent.TimeUnit; |
| |
| /** |
| * Controls the package visibility of {@link BaseTunerTvInputService}. |
| * |
| * <p>Listens to broadcast intent for {@link Intent#ACTION_BOOT_COMPLETED}, {@code |
| * UsbManager.ACTION_USB_DEVICE_ATTACHED}, and {@code UsbManager.ACTION_USB_DEVICE_ATTACHED} to |
| * update the connection status of the supported USB TV tuners. |
| */ |
| public class TunerInputController { |
| private static final boolean DEBUG = false; |
| private static final String TAG = "TunerInputController"; |
| private static final String PREFERENCE_IS_NETWORK_TUNER_ATTACHED = "network_tuner"; |
| private static final String SECURITY_PATCH_LEVEL_KEY = "ro.build.version.security_patch"; |
| private static final String SECURITY_PATCH_LEVEL_FORMAT = "yyyy-MM-dd"; |
| private static final String PLAY_STORE_LINK_TEMPLATE = "market://details?id=%s"; |
| |
| /** Action of {@link Intent} to check network connection repeatedly when it is necessary. */ |
| private static final String CHECKING_NETWORK_TUNER_STATUS = |
| "com.android.tv.action.CHECKING_NETWORK_TUNER_STATUS"; |
| |
| private static final String EXTRA_CHECKING_DURATION = |
| "com.android.tv.action.extra.CHECKING_DURATION"; |
| private static final String EXTRA_DEVICE_IP = "com.android.tv.action.extra.DEVICE_IP"; |
| |
| private static final long INITIAL_CHECKING_DURATION_MS = TimeUnit.SECONDS.toMillis(10); |
| private static final long MAXIMUM_CHECKING_DURATION_MS = TimeUnit.MINUTES.toMillis(10); |
| private static final String NOTIFICATION_CHANNEL_ID = "tuner_discovery_notification"; |
| |
| // TODO: Load settings from XML file |
| private static final TunerDevice[] TUNER_DEVICES = { |
| new TunerDevice(0x2040, 0xb123, null), // WinTV-HVR-955Q |
| new TunerDevice(0x07ca, 0x0837, null), // AverTV Volar Hybrid Q |
| // WinTV-dualHD (bulk) will be supported after 2017 April security patch. |
| new TunerDevice(0x2040, 0x826d, "2017-04-01"), // WinTV-dualHD (bulk) |
| new TunerDevice(0x2040, 0x0264, null), |
| }; |
| |
| private static final int MSG_ENABLE_INPUT_SERVICE = 1000; |
| private static final long DVB_DRIVER_CHECK_DELAY_MS = 300; |
| |
| private final ComponentName usbTunerComponent; |
| private final ComponentName networkTunerComponent; |
| private final ComponentName builtInTunerComponent; |
| private final Map<TunerDevice, ComponentName> mTunerServiceMapping = new HashMap<>(); |
| |
| private final Map<ComponentName, String> mTunerApplicationNames = new HashMap<>(); |
| private final Map<ComponentName, String> mNotificationMessages = new HashMap<>(); |
| private final Map<ComponentName, Bitmap> mNotificationLargeIcons = new HashMap<>(); |
| |
| private final CheckDvbDeviceHandler mHandler = new CheckDvbDeviceHandler(this); |
| |
| public TunerInputController(ComponentName embeddedTuner) { |
| usbTunerComponent = embeddedTuner; |
| networkTunerComponent = usbTunerComponent; |
| builtInTunerComponent = usbTunerComponent; |
| for (TunerDevice device : TUNER_DEVICES) { |
| mTunerServiceMapping.put(device, usbTunerComponent); |
| } |
| } |
| |
| /** Checks status of USB devices to see if there are available USB tuners connected. */ |
| public void onCheckingUsbTunerStatus(Context context, String action) { |
| onCheckingUsbTunerStatus(context, action, mHandler); |
| } |
| |
| private void onCheckingUsbTunerStatus( |
| Context context, String action, @NonNull CheckDvbDeviceHandler handler) { |
| Set<TunerDevice> connectedUsbTuners = getConnectedUsbTuners(context); |
| handler.removeMessages(MSG_ENABLE_INPUT_SERVICE); |
| if (!connectedUsbTuners.isEmpty()) { |
| // Need to check if DVB driver is accessible. Since the driver creation |
| // could be happen after the USB event, delay the checking by |
| // DVB_DRIVER_CHECK_DELAY_MS. |
| handler.sendMessageDelayed( |
| handler.obtainMessage(MSG_ENABLE_INPUT_SERVICE, context), |
| DVB_DRIVER_CHECK_DELAY_MS); |
| } else { |
| handleTunerStatusChanged( |
| context, |
| false, |
| connectedUsbTuners, |
| TextUtils.equals(action, UsbManager.ACTION_USB_DEVICE_DETACHED) |
| ? TunerHal.TUNER_TYPE_USB |
| : null); |
| } |
| } |
| |
| private void onNetworkTunerChanged(Context context, boolean enabled) { |
| SharedPreferences sharedPreferences = |
| PreferenceManager.getDefaultSharedPreferences(context); |
| if (sharedPreferences.contains(PREFERENCE_IS_NETWORK_TUNER_ATTACHED) |
| && sharedPreferences.getBoolean(PREFERENCE_IS_NETWORK_TUNER_ATTACHED, false) |
| == enabled) { |
| // the status is not changed |
| return; |
| } |
| if (enabled) { |
| sharedPreferences.edit().putBoolean(PREFERENCE_IS_NETWORK_TUNER_ATTACHED, true).apply(); |
| } else { |
| sharedPreferences |
| .edit() |
| .putBoolean(PREFERENCE_IS_NETWORK_TUNER_ATTACHED, false) |
| .apply(); |
| } |
| // Network tuner detection is initiated by UI. So the app should not |
| // be killed. |
| handleTunerStatusChanged( |
| context, true, getConnectedUsbTuners(context), TunerHal.TUNER_TYPE_NETWORK); |
| } |
| |
| /** |
| * See if any USB tuner hardware is attached in the system. |
| * |
| * @param context {@link Context} instance |
| * @return {@code true} if any tuner device we support is plugged in |
| */ |
| private Set<TunerDevice> getConnectedUsbTuners(Context context) { |
| UsbManager manager = (UsbManager) context.getSystemService(Context.USB_SERVICE); |
| Map<String, UsbDevice> deviceList = manager.getDeviceList(); |
| String currentSecurityLevel = |
| SystemPropertiesProxy.getString(SECURITY_PATCH_LEVEL_KEY, null); |
| |
| Set<TunerDevice> devices = new HashSet<>(); |
| for (UsbDevice device : deviceList.values()) { |
| if (DEBUG) { |
| Log.d(TAG, "Device: " + device); |
| } |
| for (TunerDevice tuner : TUNER_DEVICES) { |
| if (tuner.equalsTo(device) && tuner.isSupported(currentSecurityLevel)) { |
| Log.i(TAG, "Tuner found"); |
| devices.add(tuner); |
| } |
| } |
| } |
| return devices; |
| } |
| |
| private void handleTunerStatusChanged( |
| Context context, |
| boolean forceDontKillApp, |
| Set<TunerDevice> connectedUsbTuners, |
| Integer triggerType) { |
| Map<ComponentName, Integer> serviceToEnable = new HashMap<>(); |
| Set<ComponentName> serviceToDisable = new HashSet<>(); |
| serviceToDisable.add(builtInTunerComponent); |
| serviceToDisable.add(networkTunerComponent); |
| if (TunerFeatures.TUNER.isEnabled(context)) { |
| // TODO: support both built-in tuner and other tuners at the same time? |
| if (TunerHal.useBuiltInTuner(context)) { |
| enableTunerTvInputService( |
| context, true, false, TunerHal.TUNER_TYPE_BUILT_IN, builtInTunerComponent); |
| return; |
| } |
| SharedPreferences sharedPreferences = |
| PreferenceManager.getDefaultSharedPreferences(context); |
| if (sharedPreferences.getBoolean(PREFERENCE_IS_NETWORK_TUNER_ATTACHED, false)) { |
| serviceToEnable.put(networkTunerComponent, TunerHal.TUNER_TYPE_NETWORK); |
| } |
| } |
| for (TunerDevice device : TUNER_DEVICES) { |
| if (TunerFeatures.TUNER.isEnabled(context) && connectedUsbTuners.contains(device)) { |
| serviceToEnable.put(mTunerServiceMapping.get(device), TunerHal.TUNER_TYPE_USB); |
| } else { |
| serviceToDisable.add(mTunerServiceMapping.get(device)); |
| } |
| } |
| serviceToDisable.removeAll(serviceToEnable.keySet()); |
| for (ComponentName serviceComponent : serviceToEnable.keySet()) { |
| if (isTunerPackageInstalled(context, serviceComponent)) { |
| enableTunerTvInputService( |
| context, |
| true, |
| forceDontKillApp, |
| serviceToEnable.get(serviceComponent), |
| serviceComponent); |
| } else { |
| sendNotificationToInstallPackage(context, serviceComponent); |
| } |
| } |
| for (ComponentName serviceComponent : serviceToDisable) { |
| if (isTunerPackageInstalled(context, serviceComponent)) { |
| enableTunerTvInputService( |
| context, false, forceDontKillApp, triggerType, serviceComponent); |
| } else { |
| cancelNotificationToInstallPackage(context, serviceComponent); |
| } |
| } |
| } |
| |
| /** |
| * Enable/disable the component {@link BaseTunerTvInputService}. |
| * |
| * @param context {@link Context} instance |
| * @param enabled {@code true} to enable the service; otherwise {@code false} |
| */ |
| private static void enableTunerTvInputService( |
| Context context, |
| boolean enabled, |
| boolean forceDontKillApp, |
| Integer tunerType, |
| ComponentName serviceComponent) { |
| if (DEBUG) Log.d(TAG, "enableTunerTvInputService: " + enabled); |
| PackageManager pm = context.getPackageManager(); |
| int newState = |
| enabled |
| ? PackageManager.COMPONENT_ENABLED_STATE_ENABLED |
| : PackageManager.COMPONENT_ENABLED_STATE_DISABLED; |
| if (newState != pm.getComponentEnabledSetting(serviceComponent)) { |
| int flags = forceDontKillApp ? PackageManager.DONT_KILL_APP : 0; |
| if (serviceComponent.getPackageName().equals(context.getPackageName())) { |
| // Don't kill APP when handling input count changing. Or the following |
| // setComponentEnabledSetting() call won't work. |
| ((TvApplication) context.getApplicationContext()) |
| .handleInputCountChanged(true, enabled, true); |
| // Bundled input. Don't kill app if LiveChannels app is active since we don't want |
| // to kill the running app. |
| if (TvSingletons.getSingletons(context).getMainActivityWrapper().isCreated()) { |
| flags |= PackageManager.DONT_KILL_APP; |
| } |
| // Send/cancel the USB tuner TV input setup notification. |
| BaseTunerSetupActivity.onTvInputEnabled(context, enabled, tunerType); |
| if (!enabled && tunerType != null) { |
| if (tunerType == TunerHal.TUNER_TYPE_USB) { |
| Toast.makeText( |
| context, |
| R.string.msg_usb_tuner_disconnected, |
| Toast.LENGTH_SHORT) |
| .show(); |
| } else if (tunerType == TunerHal.TUNER_TYPE_NETWORK) { |
| Toast.makeText( |
| context, |
| R.string.msg_network_tuner_disconnected, |
| Toast.LENGTH_SHORT) |
| .show(); |
| } |
| } |
| } |
| // Enable/disable the USB tuner TV input. |
| pm.setComponentEnabledSetting(serviceComponent, newState, flags); |
| if (DEBUG) Log.d(TAG, "Status updated:" + enabled); |
| } else if (enabled && serviceComponent.getPackageName().equals(context.getPackageName())) { |
| // When # of tuners is changed or the tuner input service is switching from/to using |
| // network tuners or the device just boots. |
| TunerInputInfoUtils.updateTunerInputInfo(context); |
| } |
| } |
| |
| /** |
| * Discovers a network tuner. If the network connection is down, it won't repeatedly checking. |
| */ |
| public void executeNetworkTunerDiscoveryAsyncTask(final Context context) { |
| executeNetworkTunerDiscoveryAsyncTask(context, 0, 0); |
| } |
| |
| /** |
| * Discovers a network tuner. |
| * |
| * @param context {@link Context} |
| * @param repeatedDurationMs The time length to wait to repeatedly check network status to start |
| * finding network tuner when the network connection is not available. {@code 0} to disable |
| * repeatedly checking. |
| * @param deviceIp The previous discovered device IP, 0 if none. |
| */ |
| private void executeNetworkTunerDiscoveryAsyncTask( |
| final Context context, final long repeatedDurationMs, final int deviceIp) { |
| if (!TunerFeatures.NETWORK_TUNER.isEnabled(context)) { |
| return; |
| } |
| final Intent networkCheckingIntent = new Intent(context, IntentReceiver.class); |
| networkCheckingIntent.setAction(CHECKING_NETWORK_TUNER_STATUS); |
| if (!isNetworkConnected(context) && repeatedDurationMs > 0) { |
| sendCheckingAlarm(context, networkCheckingIntent, repeatedDurationMs); |
| } else { |
| new AsyncTask<Void, Void, Boolean>() { |
| @Override |
| protected Boolean doInBackground(Void... params) { |
| Boolean result = null; |
| // Implement and execute network tuner discovery AsyncTask here. |
| return result; |
| } |
| |
| @Override |
| protected void onPostExecute(Boolean foundNetworkTuner) { |
| if (foundNetworkTuner == null) { |
| return; |
| } |
| sendCheckingAlarm( |
| context, |
| networkCheckingIntent, |
| foundNetworkTuner ? INITIAL_CHECKING_DURATION_MS : repeatedDurationMs); |
| onNetworkTunerChanged(context, foundNetworkTuner); |
| } |
| }.execute(); |
| } |
| } |
| |
| private static boolean isNetworkConnected(Context context) { |
| ConnectivityManager cm = |
| (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE); |
| NetworkInfo networkInfo = cm.getActiveNetworkInfo(); |
| return networkInfo != null && networkInfo.isConnected(); |
| } |
| |
| private static void sendCheckingAlarm(Context context, Intent intent, long delayMs) { |
| AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE); |
| intent.putExtra(EXTRA_CHECKING_DURATION, delayMs); |
| PendingIntent alarmIntent = |
| PendingIntent.getBroadcast(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT); |
| alarmManager.set( |
| AlarmManager.ELAPSED_REALTIME, |
| SystemClock.elapsedRealtime() + delayMs, |
| alarmIntent); |
| } |
| |
| private static boolean isTunerPackageInstalled( |
| Context context, ComponentName serviceComponent) { |
| try { |
| context.getPackageManager().getPackageInfo(serviceComponent.getPackageName(), 0); |
| return true; |
| } catch (NameNotFoundException e) { |
| return false; |
| } |
| } |
| |
| private void sendNotificationToInstallPackage(Context context, ComponentName serviceComponent) { |
| if (!BuildConfig.ENG) { |
| return; |
| } |
| String applicationName = mTunerApplicationNames.get(serviceComponent); |
| if (applicationName == null) { |
| applicationName = context.getString(R.string.tuner_install_default_application_name); |
| } |
| String contentTitle = |
| context.getString( |
| R.string.tuner_install_notification_content_title, applicationName); |
| String contentText = mNotificationMessages.get(serviceComponent); |
| if (contentText == null) { |
| contentText = context.getString(R.string.tuner_install_notification_content_text); |
| } |
| Bitmap largeIcon = mNotificationLargeIcons.get(serviceComponent); |
| if (largeIcon == null) { |
| // TODO: Make a better default image. |
| largeIcon = BitmapFactory.decodeResource(context.getResources(), R.drawable.ic_store); |
| } |
| NotificationManager notificationManager = |
| (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE); |
| if (notificationManager.getNotificationChannel(NOTIFICATION_CHANNEL_ID) == null) { |
| createNotificationChannel(context, notificationManager); |
| } |
| Intent intent = new Intent(Intent.ACTION_VIEW); |
| intent.setData( |
| Uri.parse( |
| String.format( |
| PLAY_STORE_LINK_TEMPLATE, serviceComponent.getPackageName()))); |
| intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); |
| Notification.Builder builder = new Notification.Builder(context, NOTIFICATION_CHANNEL_ID); |
| builder.setAutoCancel(true) |
| .setSmallIcon(R.drawable.ic_launcher_s) |
| .setLargeIcon(largeIcon) |
| .setContentTitle(contentTitle) |
| .setContentText(contentText) |
| .setCategory(Notification.CATEGORY_RECOMMENDATION) |
| .setContentIntent(PendingIntent.getActivity(context, 0, intent, 0)); |
| notificationManager.notify(serviceComponent.getPackageName(), 0, builder.build()); |
| } |
| |
| private static void cancelNotificationToInstallPackage( |
| Context context, ComponentName serviceComponent) { |
| NotificationManager notificationManager = |
| (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE); |
| notificationManager.cancel(serviceComponent.getPackageName(), 0); |
| } |
| |
| private static void createNotificationChannel( |
| Context context, NotificationManager notificationManager) { |
| notificationManager.createNotificationChannel( |
| new NotificationChannel( |
| NOTIFICATION_CHANNEL_ID, |
| context.getResources() |
| .getString(R.string.ut_setup_notification_channel_name), |
| NotificationManager.IMPORTANCE_HIGH)); |
| } |
| |
| public static class IntentReceiver extends BroadcastReceiver { |
| |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| if (DEBUG) Log.d(TAG, "Broadcast intent received:" + intent); |
| Starter.start(context); |
| TunerInputController tunerInputController = |
| TvSingletons.getSingletons(context).getTunerInputController(); |
| if (!TunerFeatures.TUNER.isEnabled(context)) { |
| tunerInputController.handleTunerStatusChanged( |
| context, false, Collections.emptySet(), null); |
| return; |
| } |
| switch (intent.getAction()) { |
| case Intent.ACTION_BOOT_COMPLETED: |
| tunerInputController.executeNetworkTunerDiscoveryAsyncTask( |
| context, INITIAL_CHECKING_DURATION_MS, 0); |
| // fall through |
| case TvApplication.ACTION_APPLICATION_FIRST_LAUNCHED: |
| case UsbManager.ACTION_USB_DEVICE_ATTACHED: |
| case UsbManager.ACTION_USB_DEVICE_DETACHED: |
| tunerInputController.onCheckingUsbTunerStatus(context, intent.getAction()); |
| break; |
| case CHECKING_NETWORK_TUNER_STATUS: |
| long repeatedDurationMs = |
| intent.getLongExtra( |
| EXTRA_CHECKING_DURATION, INITIAL_CHECKING_DURATION_MS); |
| tunerInputController.executeNetworkTunerDiscoveryAsyncTask( |
| context, |
| Math.min(repeatedDurationMs * 2, MAXIMUM_CHECKING_DURATION_MS), |
| intent.getIntExtra(EXTRA_DEVICE_IP, 0)); |
| break; |
| default: // fall out |
| } |
| } |
| } |
| |
| /** |
| * Simple data holder for a USB device. Used to represent a tuner model, and compare against |
| * {@link UsbDevice}. |
| */ |
| private static class TunerDevice { |
| private final int vendorId; |
| private final int productId; |
| |
| // security patch level from which the specific tuner type is supported. |
| private final String minSecurityLevel; |
| |
| private TunerDevice(int vendorId, int productId, String minSecurityLevel) { |
| this.vendorId = vendorId; |
| this.productId = productId; |
| this.minSecurityLevel = minSecurityLevel; |
| } |
| |
| private boolean equalsTo(UsbDevice device) { |
| return device.getVendorId() == vendorId && device.getProductId() == productId; |
| } |
| |
| private boolean isSupported(String currentSecurityLevel) { |
| if (minSecurityLevel == null) { |
| return true; |
| } |
| |
| long supportSecurityLevelTimeStamp = 0; |
| long currentSecurityLevelTimestamp = 0; |
| try { |
| SimpleDateFormat format = new SimpleDateFormat(SECURITY_PATCH_LEVEL_FORMAT); |
| supportSecurityLevelTimeStamp = format.parse(minSecurityLevel).getTime(); |
| currentSecurityLevelTimestamp = format.parse(currentSecurityLevel).getTime(); |
| } catch (ParseException e) { |
| } |
| return supportSecurityLevelTimeStamp != 0 |
| && supportSecurityLevelTimeStamp <= currentSecurityLevelTimestamp; |
| } |
| } |
| |
| private static class CheckDvbDeviceHandler extends Handler { |
| |
| private final TunerInputController mTunerInputController; |
| private DvbDeviceAccessor mDvbDeviceAccessor; |
| |
| CheckDvbDeviceHandler(TunerInputController tunerInputController) { |
| super(Looper.getMainLooper()); |
| this.mTunerInputController = tunerInputController; |
| } |
| |
| @Override |
| public void handleMessage(Message msg) { |
| switch (msg.what) { |
| case MSG_ENABLE_INPUT_SERVICE: |
| Context context = (Context) msg.obj; |
| if (mDvbDeviceAccessor == null) { |
| mDvbDeviceAccessor = new DvbDeviceAccessor(context); |
| } |
| boolean enabled = mDvbDeviceAccessor.isDvbDeviceAvailable(); |
| mTunerInputController.handleTunerStatusChanged( |
| context, |
| false, |
| enabled |
| ? mTunerInputController.getConnectedUsbTuners(context) |
| : Collections.emptySet(), |
| TunerHal.TUNER_TYPE_USB); |
| break; |
| default: // fall out |
| } |
| } |
| } |
| } |
