Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 48824962 authored by Jerry Zhang's avatar Jerry Zhang
Browse files

Refactored setCurrentFunction and setUsbDataUnlocked into single method. 

This gets rid of an extraneous configuration change when going from
adb to adb + file transfer as previously the config would have been
reset once for functions and once for data unlocked.

It also simplifies some of the code.

Bug: 31814300
Test: manually changing usb configurations
Change-Id: Ica10a195338b2189db13113f44657393db110bee
(cherry picked from commit 7a396be6)
parent bfc5d563

cmds/svc/src/com/android/commands/svc/UsbCommand.java

+1 −1
Original line number Diff line number Diff line
@@ -50,7 +50,7 @@ public class UsbCommand extends Svc.Command { 
                IUsbManager usbMgr = IUsbManager.Stub.asInterface(ServiceManager.getService(

                        Context.USB_SERVICE));

                try {

                    usbMgr.setCurrentFunction((args.length >=3 ? args[2] : null));

                    usbMgr.setCurrentFunction((args.length >=3 ? args[2] : null), false);

                } catch (RemoteException e) {

                    System.err.println("Error communicating with UsbManager: " + e);

                }

core/java/android/hardware/usb/IUsbManager.aidl

+6 −8
Original line number Diff line number Diff line
@@ -87,15 +87,13 @@ interface IUsbManager 
    /* Returns true if the specified USB function is enabled. */

    boolean isFunctionEnabled(String function);



    /* Sets the current USB function. */

    void setCurrentFunction(String function);



    /* Sets whether USB data (for example, MTP exposed pictures) should be made

     * available on the USB connection. Unlocking data should only be done with

     * user involvement, since exposing pictures or other data could leak sensitive

     * user information.

    /* Sets the current USB function as well as whether USB data

     * (for example, MTP exposed pictures) should be made available

     * on the USB connection. Unlocking data should only be done with

     * user involvement, since exposing pictures or other data could

     * leak sensitive user information.

     */

    void setUsbDataUnlocked(boolean unlock);

    void setCurrentFunction(String function, boolean usbDataUnlocked);



    /* Allow USB debugging from the attached host. If alwaysAllow is true, add the

     * the public key to list of host keys that the user has approved.

core/java/android/hardware/usb/UsbManager.java

+8 −18
Original line number Diff line number Diff line
@@ -530,33 +530,23 @@ public class UsbManager { 
     * {@link #USB_FUNCTION_MIDI}, {@link #USB_FUNCTION_MTP}, {@link #USB_FUNCTION_PTP},

     * or {@link #USB_FUNCTION_RNDIS}.

     * </p><p>

     * Also sets whether USB data (for example, MTP exposed pictures) should be made available

     * on the USB connection when in device mode. Unlocking usb data should only be done with

     * user involvement, since exposing pictures or other data could leak sensitive

     * user information.

     * </p><p>

     * Note: This function is asynchronous and may fail silently without applying

     * the requested changes.

     * </p>

     *

     * @param function name of the USB function, or null to restore the default function

     * @param usbDataUnlocked whether user data is accessible

     *

     * {@hide}

     */

    public void setCurrentFunction(String function) {

        try {

            mService.setCurrentFunction(function);

        } catch (RemoteException e) {

            throw e.rethrowFromSystemServer();

        }

    }



    /**

     * Sets whether USB data (for example, MTP exposed pictures) should be made available

     * on the USB connection when in device mode. Unlocking usb data should only be done with

     * user involvement, since exposing pictures or other data could leak sensitive

     * user information.

     *

     * {@hide}

     */

    public void setUsbDataUnlocked(boolean unlocked) {

    public void setCurrentFunction(String function, boolean usbDataUnlocked) {

        try {

            mService.setUsbDataUnlocked(unlocked);

            mService.setCurrentFunction(function, usbDataUnlocked);

        } catch (RemoteException e) {

            throw e.rethrowFromSystemServer();

        }

services/core/java/com/android/server/connectivity/Tethering.java

+2 −2
Original line number Diff line number Diff line
@@ -897,7 +897,7 @@ public class Tethering extends BaseNetworkObserver implements IControlsTethering 
                    }

                } else {

                    mUsbTetherRequested = true;

                    usbManager.setCurrentFunction(UsbManager.USB_FUNCTION_RNDIS);

                    usbManager.setCurrentFunction(UsbManager.USB_FUNCTION_RNDIS, false);

                }

            } else {

                final long ident = Binder.clearCallingIdentity();
@@ -907,7 +907,7 @@ public class Tethering extends BaseNetworkObserver implements IControlsTethering 
                    Binder.restoreCallingIdentity(ident);

                }

                if (mRndisEnabled) {

                    usbManager.setCurrentFunction(null);

                    usbManager.setCurrentFunction(null, false);

                }

                mUsbTetherRequested = false;

            }

services/usb/java/com/android/server/usb/UsbDeviceManager.java

+31 −36
Original line number Diff line number Diff line
@@ -109,9 +109,8 @@ public class UsbDeviceManager { 
    private static final int MSG_SYSTEM_READY = 3;

    private static final int MSG_BOOT_COMPLETED = 4;

    private static final int MSG_USER_SWITCHED = 5;

    private static final int MSG_SET_USB_DATA_UNLOCKED = 6;

    private static final int MSG_UPDATE_USER_RESTRICTIONS = 7;

    private static final int MSG_UPDATE_HOST_STATE = 8;

    private static final int MSG_UPDATE_USER_RESTRICTIONS = 6;

    private static final int MSG_UPDATE_HOST_STATE = 7;



    private static final int AUDIO_MODE_SOURCE = 1;
@@ -288,7 +287,7 @@ public class UsbDeviceManager { 


        if (functions != null) {

            mAccessoryModeRequestTime = SystemClock.elapsedRealtime();

            setCurrentFunctions(functions);

            setCurrentFunctions(functions, false);

        }

    }
@@ -352,7 +351,7 @@ public class UsbDeviceManager { 
                            UsbManager.removeFunction(persisted, UsbManager.USB_FUNCTION_MTP));

                }



                setEnabledFunctions(null, false);

                setEnabledFunctions(null, false, false);



                String state = FileUtils.readTextFile(new File(STATE_PATH), 0, null).trim();

                updateState(state);
@@ -384,6 +383,14 @@ public class UsbDeviceManager { 
            sendMessage(m);

        }



        public void sendMessage(int what, Object arg, boolean arg1) {

            removeMessages(what);

            Message m = Message.obtain(this, what);

            m.obj = arg;

            m.arg1 = (arg1 ? 1 : 0);

            sendMessage(m);

        }



        public void updateState(String state) {

            int connected, configured;
@@ -448,14 +455,6 @@ public class UsbDeviceManager { 
            return waitForState(config);

        }



        private void setUsbDataUnlocked(boolean enable) {

            if (DEBUG) Slog.d(TAG, "setUsbDataUnlocked: " + enable);

            mUsbDataUnlocked = enable;

            updateUsbNotification();

            updateUsbStateBroadcastIfNeeded();

            setEnabledFunctions(mCurrentFunctions, true);

        }



        private void setAdbEnabled(boolean enable) {

            if (DEBUG) Slog.d(TAG, "setAdbEnabled: " + enable);

            if (enable != mAdbEnabled) {
@@ -473,7 +472,7 @@ public class UsbDeviceManager { 
                    oldFunctions = UsbManager.USB_FUNCTION_NONE;

                }



                setEnabledFunctions(oldFunctions, false);

                setEnabledFunctions(oldFunctions, true, mUsbDataUnlocked);

                updateAdbNotification();

            }
@@ -485,10 +484,17 @@ public class UsbDeviceManager { 
        /**

         * Evaluates USB function policies and applies the change accordingly.

         */

        private void setEnabledFunctions(String functions, boolean forceRestart) {

        private void setEnabledFunctions(String functions, boolean forceRestart,

                boolean usbDataUnlocked) {

            if (DEBUG) Slog.d(TAG, "setEnabledFunctions functions=" + functions + ", "

                    + "forceRestart=" + forceRestart);



            if (usbDataUnlocked != mUsbDataUnlocked) {

                mUsbDataUnlocked = usbDataUnlocked;

                updateUsbNotification();

                forceRestart = true;

            }



            // Try to set the enabled functions.

            final String oldFunctions = mCurrentFunctions;

            final boolean oldFunctionsApplied = mCurrentFunctionsApplied;
@@ -591,7 +597,7 @@ public class UsbDeviceManager { 
                // make sure accessory mode is off

                // and restore default functions

                Slog.d(TAG, "exited USB accessory mode");

                setEnabledFunctions(null, false);

                setEnabledFunctions(null, false, false);



                if (mCurrentAccessory != null) {

                    if (mBootCompleted) {
@@ -720,10 +726,7 @@ public class UsbDeviceManager { 
                case MSG_UPDATE_STATE:

                    mConnected = (msg.arg1 == 1);

                    mConfigured = (msg.arg2 == 1);

                    if (!mConnected) {

                        // When a disconnect occurs, relock access to sensitive user data

                        mUsbDataUnlocked = false;

                    }



                    updateUsbNotification();

                    updateAdbNotification();

                    if (UsbManager.containsFunction(mCurrentFunctions,
@@ -731,7 +734,7 @@ public class UsbDeviceManager { 
                        updateCurrentAccessory();

                    } else if (!mConnected) {

                        // restore defaults when USB is disconnected

                        setEnabledFunctions(null, false);

                        setEnabledFunctions(null, false, false);

                    }

                    if (mBootCompleted) {

                        updateUsbStateBroadcastIfNeeded();
@@ -754,13 +757,10 @@ public class UsbDeviceManager { 
                    break;

                case MSG_SET_CURRENT_FUNCTIONS:

                    String functions = (String)msg.obj;

                    setEnabledFunctions(functions, false);

                    setEnabledFunctions(functions, false, msg.arg1 == 1);

                    break;

                case MSG_UPDATE_USER_RESTRICTIONS:

                    setEnabledFunctions(mCurrentFunctions, false);

                    break;

                case MSG_SET_USB_DATA_UNLOCKED:

                    setUsbDataUnlocked(msg.arg1 == 1);

                    setEnabledFunctions(mCurrentFunctions, false, mUsbDataUnlocked);

                    break;

                case MSG_SYSTEM_READY:

                    updateUsbNotification();
@@ -788,8 +788,7 @@ public class UsbDeviceManager { 
                            Slog.v(TAG, "Current user switched to " + mCurrentUser

                                    + "; resetting USB host stack for MTP or PTP");

                            // avoid leaking sensitive data from previous user

                            mUsbDataUnlocked = false;

                            setEnabledFunctions(mCurrentFunctions, true);

                            setEnabledFunctions(mCurrentFunctions, true, false);

                        }

                        mCurrentUser = msg.arg1;

                    }
@@ -973,14 +972,10 @@ public class UsbDeviceManager { 
        return UsbManager.containsFunction(SystemProperties.get(USB_CONFIG_PROPERTY), function);

    }



    public void setCurrentFunctions(String functions) {

        if (DEBUG) Slog.d(TAG, "setCurrentFunctions(" + functions + ")");

        mHandler.sendMessage(MSG_SET_CURRENT_FUNCTIONS, functions);

    }



    public void setUsbDataUnlocked(boolean unlocked) {

        if (DEBUG) Slog.d(TAG, "setUsbDataUnlocked(" + unlocked + ")");

        mHandler.sendMessage(MSG_SET_USB_DATA_UNLOCKED, unlocked);

    public void setCurrentFunctions(String functions, boolean usbDataUnlocked) {

        if (DEBUG) Slog.d(TAG, "setCurrentFunctions(" + functions + ", " +

				usbDataUnlocked + ")");

        mHandler.sendMessage(MSG_SET_CURRENT_FUNCTIONS, functions, usbDataUnlocked);

    }



    private void readOemUsbOverrideConfig() {