| /* |
| * 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.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.hardware.usb.UsbDevice; |
| import android.hardware.usb.UsbManager; |
| import android.net.ConnectivityManager; |
| import android.net.NetworkInfo; |
| 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.Features; |
| import com.android.tv.R; |
| import com.android.tv.TvApplication; |
| import com.android.tv.common.SoftPreconditions; |
| import com.android.tv.tuner.setup.TunerSetupActivity; |
| import com.android.tv.tuner.tvinput.TunerTvInputService; |
| import com.android.tv.tuner.util.SystemPropertiesProxy; |
| import com.android.tv.tuner.util.TunerInputInfoUtils; |
| |
| import java.text.ParseException; |
| import java.text.SimpleDateFormat; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.concurrent.TimeUnit; |
| |
| /** |
| * Controls the package visibility of {@link TunerTvInputService}. |
| * <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 = true; |
| 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"; |
| |
| /** |
| * Action of {@link Intent} to check network connection repeatedly when it is necessary. |
| */ |
| private static final String CHECKING_NETWORK_CONNECTION = |
| "com.android.tv.action.CHECKING_NETWORK_CONNECTION"; |
| |
| private static final String EXTRA_CHECKING_DURATION = |
| "com.android.tv.action.extra.CHECKING_DURATION"; |
| |
| 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 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) |
| // STOPSHIP: Add WinTV-soloHD (Isoc) temporary for test. Remove this after test complete. |
| new TunerDevice(0x2040, 0x0264, null), |
| }; |
| |
| private static final int MSG_ENABLE_INPUT_SERVICE = 1000; |
| private static final long DVB_DRIVER_CHECK_DELAY_MS = 300; |
| |
| /** |
| * Checks status of USB devices to see if there are available USB tuners connected. |
| */ |
| public static void onCheckingUsbTunerStatus(Context context, String action) { |
| onCheckingUsbTunerStatus(context, action, new CheckDvbDeviceHandler()); |
| } |
| |
| private static void onCheckingUsbTunerStatus(Context context, String action, |
| @NonNull CheckDvbDeviceHandler handler) { |
| SharedPreferences sharedPreferences = |
| PreferenceManager.getDefaultSharedPreferences(context); |
| if (TunerHal.useBuiltInTuner(context)) { |
| enableTunerTvInputService(context, true, false, TunerHal.TUNER_TYPE_BUILT_IN); |
| return; |
| } |
| // Falls back to the below to check USB tuner devices. |
| boolean enabled = isUsbTunerConnected(context); |
| handler.removeMessages(MSG_ENABLE_INPUT_SERVICE); |
| if (enabled) { |
| // 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 { |
| if (sharedPreferences.getBoolean(PREFERENCE_IS_NETWORK_TUNER_ATTACHED, false)) { |
| // Since network tuner is attached, do not disable TunerTvInput, |
| // just updates the TvInputInfo. |
| TunerInputInfoUtils.updateTunerInputInfo(context); |
| return; |
| } |
| enableTunerTvInputService(context, false, false, TextUtils |
| .equals(action, UsbManager.ACTION_USB_DEVICE_DETACHED) ? |
| TunerHal.TUNER_TYPE_USB : null); |
| } |
| } |
| |
| private static void onNetworkTunerChanged(Context context, boolean enabled) { |
| SharedPreferences sharedPreferences = |
| PreferenceManager.getDefaultSharedPreferences(context); |
| if (enabled) { |
| // Network tuner detection is initiated by UI. So the app should not |
| // be killed. |
| sharedPreferences.edit().putBoolean(PREFERENCE_IS_NETWORK_TUNER_ATTACHED, true).apply(); |
| enableTunerTvInputService(context, true, true, TunerHal.TUNER_TYPE_NETWORK); |
| } else { |
| sharedPreferences.edit() |
| .putBoolean(PREFERENCE_IS_NETWORK_TUNER_ATTACHED, false).apply(); |
| if(!isUsbTunerConnected(context) && !TunerHal.useBuiltInTuner(context)) { |
| // Network tuner detection is initiated by UI. So the app should not |
| // be killed. |
| enableTunerTvInputService(context, false, true, TunerHal.TUNER_TYPE_NETWORK); |
| } else { |
| // Since USB tuner is attached, do not disable TunerTvInput, |
| // just updates the TvInputInfo. |
| TunerInputInfoUtils.updateTunerInputInfo(context); |
| } |
| } |
| } |
| |
| /** |
| * 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 static boolean isUsbTunerConnected(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); |
| |
| for (UsbDevice device : deviceList.values()) { |
| if (DEBUG) { |
| Log.d(TAG, "Device: " + device); |
| } |
| for (TunerDevice tuner : TUNER_DEVICES) { |
| if (tuner.equals(device) && tuner.isSupported(currentSecurityLevel)) { |
| Log.i(TAG, "Tuner found"); |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Enable/disable the component {@link TunerTvInputService}. |
| * |
| * @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) { |
| if (DEBUG) Log.d(TAG, "enableTunerTvInputService: " + enabled); |
| PackageManager pm = context.getPackageManager(); |
| ComponentName componentName = new ComponentName(context, TunerTvInputService.class); |
| |
| // Don't kill app by enabling/disabling TvActivity. If LC is killed by enabling/disabling |
| // TvActivity, the following pm.setComponentEnabledSetting doesn't work. |
| ((TvApplication) context.getApplicationContext()).handleInputCountChanged( |
| true, enabled, true); |
| // Since PackageManager.DONT_KILL_APP delays the operation by 10 seconds |
| // (PackageManagerService.BROADCAST_DELAY), we'd better avoid using it. It is used only |
| // when the LiveChannels app is active since we don't want to kill the running app. |
| int flags = forceDontKillApp |
| || TvApplication.getSingletons(context).getMainActivityWrapper().isCreated() |
| ? PackageManager.DONT_KILL_APP : 0; |
| int newState = enabled ? PackageManager.COMPONENT_ENABLED_STATE_ENABLED |
| : PackageManager.COMPONENT_ENABLED_STATE_DISABLED; |
| if (newState != pm.getComponentEnabledSetting(componentName)) { |
| // Send/cancel the USB tuner TV input setup notification. |
| TunerSetupActivity.onTvInputEnabled(context, enabled, tunerType); |
| // Enable/disable the USB tuner TV input. |
| pm.setComponentEnabledSetting(componentName, newState, flags); |
| 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(); |
| } |
| } |
| if (DEBUG) Log.d(TAG, "Status updated:" + enabled); |
| } else if (enabled) { |
| // 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 static void executeNetworkTunerDiscoveryAsyncTask(final Context context) { |
| boolean runningInMainProcess = |
| TvApplication.getSingletons(context).isRunningInMainProcess(); |
| SoftPreconditions.checkState(runningInMainProcess); |
| if (!runningInMainProcess) { |
| return; |
| } |
| executeNetworkTunerDiscoveryAsyncTask(context, 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. |
| */ |
| private static void executeNetworkTunerDiscoveryAsyncTask(final Context context, |
| final long repeatedDurationMs) { |
| if (!Features.NETWORK_TUNER.isEnabled(context)) { |
| return; |
| } |
| new AsyncTask<Void, Void, Boolean>() { |
| @Override |
| protected Boolean doInBackground(Void... params) { |
| if (isNetworkConnected(context)) { |
| // Implement and execute network tuner discovery AsyncTask here. |
| } else if (repeatedDurationMs > 0) { |
| AlarmManager alarmManager = |
| (AlarmManager) context.getSystemService(Context.ALARM_SERVICE); |
| Intent networkCheckingIntent = new Intent(context, IntentReceiver.class); |
| networkCheckingIntent.setAction(CHECKING_NETWORK_CONNECTION); |
| networkCheckingIntent.putExtra(EXTRA_CHECKING_DURATION, repeatedDurationMs); |
| PendingIntent alarmIntent = PendingIntent.getBroadcast( |
| context, 0, networkCheckingIntent, PendingIntent.FLAG_UPDATE_CURRENT); |
| alarmManager.set(AlarmManager.ELAPSED_REALTIME, SystemClock.elapsedRealtime() |
| + repeatedDurationMs, alarmIntent); |
| } |
| return null; |
| } |
| |
| @Override |
| protected void onPostExecute(Boolean result) { |
| if (result == null) { |
| return; |
| } |
| onNetworkTunerChanged(context, result); |
| } |
| }.execute(); |
| } |
| |
| private static boolean isNetworkConnected(Context context) { |
| ConnectivityManager cm = (ConnectivityManager) |
| context.getSystemService(Context.CONNECTIVITY_SERVICE); |
| NetworkInfo networkInfo = cm.getActiveNetworkInfo(); |
| return networkInfo != null && networkInfo.isConnected(); |
| } |
| |
| public static class IntentReceiver extends BroadcastReceiver { |
| private final CheckDvbDeviceHandler mHandler = new CheckDvbDeviceHandler(); |
| |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| if (DEBUG) Log.d(TAG, "Broadcast intent received:" + intent); |
| TvApplication.setCurrentRunningProcess(context, true); |
| if (!Features.TUNER.isEnabled(context)) { |
| enableTunerTvInputService(context, false, false, null); |
| return; |
| } |
| switch (intent.getAction()) { |
| case Intent.ACTION_BOOT_COMPLETED: |
| executeNetworkTunerDiscoveryAsyncTask(context, INITIAL_CHECKING_DURATION_MS); |
| case TvApplication.ACTION_APPLICATION_FIRST_LAUNCHED: |
| case UsbManager.ACTION_USB_DEVICE_ATTACHED: |
| case UsbManager.ACTION_USB_DEVICE_DETACHED: |
| onCheckingUsbTunerStatus(context, intent.getAction(), mHandler); |
| break; |
| case CHECKING_NETWORK_CONNECTION: |
| long repeatedDurationMs = intent.getLongExtra(EXTRA_CHECKING_DURATION, |
| INITIAL_CHECKING_DURATION_MS); |
| executeNetworkTunerDiscoveryAsyncTask(context, |
| Math.min(repeatedDurationMs * 2, MAXIMUM_CHECKING_DURATION_MS)); |
| break; |
| } |
| } |
| } |
| |
| /** |
| * 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 equals(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 DvbDeviceAccessor mDvbDeviceAccessor; |
| |
| CheckDvbDeviceHandler() { |
| super(Looper.getMainLooper()); |
| } |
| |
| @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(); |
| enableTunerTvInputService( |
| context, enabled, false, enabled ? TunerHal.TUNER_TYPE_USB : null); |
| break; |
| } |
| } |
| } |
| } |
