src/com/android/settings/connecteddevice/UsbModePreferenceController.java

   1 /*
   2  * Copyright (C) 2016 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.android.settings.connecteddevice;
  17
  18 import android.content.BroadcastReceiver;
  19 import android.content.Context;
  20 import android.content.Intent;
  21 import android.content.IntentFilter;
  22 import android.hardware.usb.UsbManager;
  23 import android.support.annotation.VisibleForTesting;
  24 import android.support.v7.preference.Preference;
  25 import android.support.v7.preference.PreferenceScreen;
  26
  27 import com.android.settings.core.PreferenceController;
  28 import com.android.settings.R;
  29 import com.android.settings.deviceinfo.UsbBackend;
  30 import com.android.settingslib.core.lifecycle.LifecycleObserver;
  31 import com.android.settingslib.core.lifecycle.events.OnPause;
  32 import com.android.settingslib.core.lifecycle.events.OnResume;
  33
  34 public class UsbModePreferenceController extends PreferenceController
  35         implements LifecycleObserver, OnResume, OnPause {
  36
  37     private static final String KEY_USB_MODE = "usb_mode";
  38
  39     private UsbBackend mUsbBackend;
  40     private UsbConnectionBroadcastReceiver mUsbReceiver;
  41     private Preference mUsbPreference;
  42
  43     public UsbModePreferenceController(Context context, UsbBackend usbBackend) {
  44         super(context);
  45         mUsbBackend = usbBackend;
  46         mUsbReceiver = new UsbConnectionBroadcastReceiver();
  47     }
  48
  49     @Override
  50     public void displayPreference(PreferenceScreen screen) {
  51         super.displayPreference(screen);
  52         mUsbPreference = screen.findPreference(KEY_USB_MODE);
  53         updataSummary(mUsbPreference);
  54     }
  55
  56     @Override
  57     public void updateState(Preference preference) {
  58         updataSummary(preference);
  59     }
  60
  61     @Override
  62     public boolean isAvailable() {
  63         return true;
  64     }
  65
  66     @Override
  67     public String getPreferenceKey() {
  68         return KEY_USB_MODE;
  69     }
  70
  71     @Override
  72     public void onPause() {
  73         mUsbReceiver.unregister();
  74     }
  75
  76     @Override
  77     public void onResume() {
  78         mUsbReceiver.register();
  79     }
  80
  81     @VisibleForTesting
  82     int getSummary(int mode) {
  83         switch (mode) {
  84             case UsbBackend.MODE_POWER_SINK | UsbBackend.MODE_DATA_NONE:
  85                 return R.string.usb_summary_charging_only;
  86             case UsbBackend.MODE_POWER_SOURCE | UsbBackend.MODE_DATA_NONE:
  87                 return R.string.usb_summary_power_only;
  88             case UsbBackend.MODE_POWER_SINK | UsbBackend.MODE_DATA_MTP:
  89                 return R.string.usb_summary_file_transfers;
  90             case UsbBackend.MODE_POWER_SINK | UsbBackend.MODE_DATA_PTP:
  91                 return R.string.usb_summary_photo_transfers;
  92             case UsbBackend.MODE_POWER_SINK | UsbBackend.MODE_DATA_MIDI:
  93                 return R.string.usb_summary_MIDI;
  94         }
  95         return 0;
  96     }
  97
  98     private void updataSummary(Preference preference) {
  99         updataSummary(preference, mUsbBackend.getCurrentMode());
 100     }
 101
 102     private void updataSummary(Preference preference, int mode) {
 103         if (preference != null) {
 104             if (mUsbReceiver.isConnected()) {
 105                 preference.setEnabled(true);
 106                 preference.setSummary(getSummary(mode));
 107             } else {
 108                 preference.setSummary(R.string.disconnected);
 109                 preference.setEnabled(false);
 110             }
 111         }
 112     }
 113
 114     private class UsbConnectionBroadcastReceiver extends BroadcastReceiver {
 115         private boolean mListeningToUsbEvents;
 116         private boolean mConnected;
 117
 118         @Override
 119         public void onReceive(Context context, Intent intent) {
 120             boolean connected = intent != null
 121                     && intent.getExtras().getBoolean(UsbManager.USB_CONNECTED);
 122             if (connected != mConnected) {
 123                 mConnected = connected;
 124                 updataSummary(mUsbPreference);
 125             }
 126         }
 127
 128         public void register() {
 129             if (!mListeningToUsbEvents) {
 130                 IntentFilter intentFilter = new IntentFilter(UsbManager.ACTION_USB_STATE);
 131                 Intent intent = mContext.registerReceiver(this, intentFilter);
 132                 mConnected = intent != null
 133                         && intent.getExtras().getBoolean(UsbManager.USB_CONNECTED);
 134                 mListeningToUsbEvents = true;
 135             }
 136         }
 137
 138         public void unregister() {
 139             if (mListeningToUsbEvents) {
 140                 mContext.unregisterReceiver(this);
 141                 mListeningToUsbEvents = false;
 142             }
 143         }
 144
 145         public boolean isConnected() {
 146             return mConnected;
 147         }
 148     }
 149
 150 }