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

Commit b0377bbf authored by Yohei Yukawa's avatar Yohei Yukawa
Browse files

Use Java7 diamond operator in IMMS/IMS. 

This CL changes nothing except for deleting redundant type
parameters thanks to diamond operator.

Bug: 22285167
Change-Id: I12807f147bd0ca72c243e6fff87250d8f32d556b
parent f304c729

core/java/android/view/inputmethod/InputMethodManager.java

+4 −5
Original line number Diff line number Diff line
@@ -377,8 +377,8 @@ public final class InputMethodManager { 
     */

    private int mRequestUpdateCursorAnchorInfoMonitorMode = REQUEST_UPDATE_CURSOR_ANCHOR_INFO_NONE;



    final Pool<PendingEvent> mPendingEventPool = new SimplePool<PendingEvent>(20);

    final SparseArray<PendingEvent> mPendingEvents = new SparseArray<PendingEvent>(20);

    final Pool<PendingEvent> mPendingEventPool = new SimplePool<>(20);

    final SparseArray<PendingEvent> mPendingEvents = new SparseArray<>(20);



    // -----------------------------------------------------------
@@ -2033,8 +2033,7 @@ public final class InputMethodManager { 
     */

    public Map<InputMethodInfo, List<InputMethodSubtype>> getShortcutInputMethodsAndSubtypes() {

        synchronized (mH) {

            HashMap<InputMethodInfo, List<InputMethodSubtype>> ret =

                    new HashMap<InputMethodInfo, List<InputMethodSubtype>>();

            HashMap<InputMethodInfo, List<InputMethodSubtype>> ret = new HashMap<>();

            try {

                // TODO: We should change the return type from List<Object> to List<Parcelable>

                List<Object> info = mService.getShortcutInputMethodsAndSubtypes();
@@ -2049,7 +2048,7 @@ public final class InputMethodManager { 
                                Log.e(TAG, "IMI list already contains the same InputMethod.");

                                break;

                            }

                            subtypes = new ArrayList<InputMethodSubtype>();

                            subtypes = new ArrayList<>();

                            ret.put((InputMethodInfo)o, subtypes);

                        } else if (subtypes != null && o instanceof InputMethodSubtype) {

                            subtypes.add((InputMethodSubtype)o);

core/java/com/android/internal/inputmethod/InputMethodUtils.java

+17 −21
Original line number Diff line number Diff line
@@ -428,7 +428,7 @@ public class InputMethodUtils { 
    }



    public static ArrayList<InputMethodSubtype> getSubtypes(InputMethodInfo imi) {

        ArrayList<InputMethodSubtype> subtypes = new ArrayList<InputMethodSubtype>();

        ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();

        final int subtypeCount = imi.getSubtypeCount();

        for (int i = 0; i < subtypeCount; ++i) {

            subtypes.add(imi.getSubtypeAt(i));
@@ -438,7 +438,7 @@ public class InputMethodUtils { 


    public static ArrayList<InputMethodSubtype> getOverridingImplicitlyEnabledSubtypes(

            InputMethodInfo imi, String mode) {

        ArrayList<InputMethodSubtype> subtypes = new ArrayList<InputMethodSubtype>();

        ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();

        final int subtypeCount = imi.getSubtypeCount();

        for (int i = 0; i < subtypeCount; ++i) {

            final InputMethodSubtype subtype = imi.getSubtypeAt(i);
@@ -496,10 +496,9 @@ public class InputMethodUtils { 
            Resources res, InputMethodInfo imi) {

        final List<InputMethodSubtype> subtypes = InputMethodUtils.getSubtypes(imi);

        final String systemLocale = res.getConfiguration().locale.toString();

        if (TextUtils.isEmpty(systemLocale)) return new ArrayList<InputMethodSubtype>();

        if (TextUtils.isEmpty(systemLocale)) return new ArrayList<>();

        final String systemLanguage = res.getConfiguration().locale.getLanguage();

        final HashMap<String, InputMethodSubtype> applicableModeAndSubtypesMap =

                new HashMap<String, InputMethodSubtype>();

        final HashMap<String, InputMethodSubtype> applicableModeAndSubtypesMap = new HashMap<>();

        final int N = subtypes.size();

        for (int i = 0; i < N; ++i) {

            // scan overriding implicitly enabled subtypes.
@@ -512,7 +511,7 @@ public class InputMethodUtils { 
            }

        }

        if (applicableModeAndSubtypesMap.size() > 0) {

            return new ArrayList<InputMethodSubtype>(applicableModeAndSubtypesMap.values());

            return new ArrayList<>(applicableModeAndSubtypesMap.values());

        }

        for (int i = 0; i < N; ++i) {

            final InputMethodSubtype subtype = subtypes.get(i);
@@ -545,7 +544,7 @@ public class InputMethodUtils { 
        }

        final InputMethodSubtype keyboardSubtype

                = applicableModeAndSubtypesMap.get(SUBTYPE_MODE_KEYBOARD);

        final ArrayList<InputMethodSubtype> applicableSubtypes = new ArrayList<InputMethodSubtype>(

        final ArrayList<InputMethodSubtype> applicableSubtypes = new ArrayList<>(

                applicableModeAndSubtypesMap.values());

        if (keyboardSubtype != null && !keyboardSubtype.containsExtraValueKey(TAG_ASCII_CAPABLE)) {

            for (int i = 0; i < N; ++i) {
@@ -818,8 +817,7 @@ public class InputMethodUtils { 
                String enabledInputMethodsStr,

                TextUtils.SimpleStringSplitter inputMethodSplitter,

                TextUtils.SimpleStringSplitter subtypeSplitter) {

            ArrayList<Pair<String, ArrayList<String>>> imsList =

                    new ArrayList<Pair<String, ArrayList<String>>>();

            ArrayList<Pair<String, ArrayList<String>>> imsList = new ArrayList<>();

            if (TextUtils.isEmpty(enabledInputMethodsStr)) {

                return imsList;

            }
@@ -828,13 +826,13 @@ public class InputMethodUtils { 
                String nextImsStr = inputMethodSplitter.next();

                subtypeSplitter.setString(nextImsStr);

                if (subtypeSplitter.hasNext()) {

                    ArrayList<String> subtypeHashes = new ArrayList<String>();

                    ArrayList<String> subtypeHashes = new ArrayList<>();

                    // The first element is ime id.

                    String imeId = subtypeSplitter.next();

                    while (subtypeSplitter.hasNext()) {

                        subtypeHashes.add(subtypeSplitter.next());

                    }

                    imsList.add(new Pair<String, ArrayList<String>>(imeId, subtypeHashes));

                    imsList.add(new Pair<>(imeId, subtypeHashes));

                }

            }

            return imsList;
@@ -901,8 +899,7 @@ public class InputMethodUtils { 
                InputMethodInfo imi) {

            List<Pair<String, ArrayList<String>>> imsList =

                    getEnabledInputMethodsAndSubtypeListLocked();

            ArrayList<InputMethodSubtype> enabledSubtypes =

                    new ArrayList<InputMethodSubtype>();

            ArrayList<InputMethodSubtype> enabledSubtypes = new ArrayList<>();

            if (imi != null) {

                for (Pair<String, ArrayList<String>> imsPair : imsList) {

                    InputMethodInfo info = mMethodMap.get(imsPair.first);
@@ -991,7 +988,7 @@ public class InputMethodUtils { 


        private List<InputMethodInfo> createEnabledInputMethodListLocked(

                List<Pair<String, ArrayList<String>>> imsList) {

            final ArrayList<InputMethodInfo> res = new ArrayList<InputMethodInfo>();

            final ArrayList<InputMethodInfo> res = new ArrayList<>();

            for (Pair<String, ArrayList<String>> ims: imsList) {

                InputMethodInfo info = mMethodMap.get(ims.first);

                if (info != null) {
@@ -1004,12 +1001,11 @@ public class InputMethodUtils { 
        private List<Pair<InputMethodInfo, ArrayList<String>>>

                createEnabledInputMethodAndSubtypeHashCodeListLocked(

                        List<Pair<String, ArrayList<String>>> imsList) {

            final ArrayList<Pair<InputMethodInfo, ArrayList<String>>> res

                    = new ArrayList<Pair<InputMethodInfo, ArrayList<String>>>();

            final ArrayList<Pair<InputMethodInfo, ArrayList<String>>> res = new ArrayList<>();

            for (Pair<String, ArrayList<String>> ims : imsList) {

                InputMethodInfo info = mMethodMap.get(ims.first);

                if (info != null) {

                    res.add(new Pair<InputMethodInfo, ArrayList<String>>(info, ims.second));

                    res.add(new Pair<>(info, ims.second));

                }

            }

            return res;
@@ -1118,7 +1114,7 @@ public class InputMethodUtils { 
                        if (DEBUG) {

                            Slog.d(TAG, "Enabled subtype found in the history: " + subtypeHashCode);

                        }

                        return new Pair<String, String>(imeInTheHistory, subtypeHashCode);

                        return new Pair<>(imeInTheHistory, subtypeHashCode);

                    }

                }

            }
@@ -1179,7 +1175,7 @@ public class InputMethodUtils { 
        }



        private List<Pair<String, String>> loadInputMethodAndSubtypeHistoryLocked() {

            ArrayList<Pair<String, String>> imsList = new ArrayList<Pair<String, String>>();

            ArrayList<Pair<String, String>> imsList = new ArrayList<>();

            final String subtypeHistoryStr = getSubtypeHistoryStr();

            if (TextUtils.isEmpty(subtypeHistoryStr)) {

                return imsList;
@@ -1196,7 +1192,7 @@ public class InputMethodUtils { 
                        subtypeId = mSubtypeSplitter.next();

                        break;

                    }

                    imsList.add(new Pair<String, String>(imeId, subtypeId));

                    imsList.add(new Pair<>(imeId, subtypeId));

                }

            }

            return imsList;
@@ -1294,7 +1290,7 @@ public class InputMethodUtils { 
        public HashMap<InputMethodInfo, List<InputMethodSubtype>>

                getExplicitlyOrImplicitlyEnabledInputMethodsAndSubtypeListLocked(Context context) {

            HashMap<InputMethodInfo, List<InputMethodSubtype>> enabledInputMethodAndSubtypes =

                    new HashMap<InputMethodInfo, List<InputMethodSubtype>>();

                    new HashMap<>();

            for (InputMethodInfo imi: getEnabledInputMethodListLocked()) {

                enabledInputMethodAndSubtypes.put(

                        imi, getEnabledInputMethodSubtypeListLocked(context, imi, true));

services/core/java/com/android/server/InputMethodManagerService.java

+20 −25
Original line number Diff line number Diff line
@@ -197,10 +197,10 @@ public class InputMethodManagerService extends IInputMethodManager.Stub 


    // All known input methods.  mMethodMap also serves as the global

    // lock for this class.

    final ArrayList<InputMethodInfo> mMethodList = new ArrayList<InputMethodInfo>();

    final HashMap<String, InputMethodInfo> mMethodMap = new HashMap<String, InputMethodInfo>();

    final ArrayList<InputMethodInfo> mMethodList = new ArrayList<>();

    final HashMap<String, InputMethodInfo> mMethodMap = new HashMap<>();

    private final LruCache<SuggestionSpan, InputMethodInfo> mSecureSuggestionSpans =

            new LruCache<SuggestionSpan, InputMethodInfo>(SECURE_SUGGESTION_SPANS_MAX_SIZE);

            new LruCache<>(SECURE_SUGGESTION_SPANS_MAX_SIZE);

    private final InputMethodSubtypeSwitchingController mSwitchingController;



    // Used to bring IME service up to visible adjustment while it is being shown.
@@ -277,8 +277,7 @@ public class InputMethodManagerService extends IInputMethodManager.Stub 
        }

    }



    final HashMap<IBinder, ClientState> mClients

            = new HashMap<IBinder, ClientState>();

    final HashMap<IBinder, ClientState> mClients = new HashMap<>();



    /**

     * Set once the system is ready to run third party code.
@@ -329,8 +328,7 @@ public class InputMethodManagerService extends IInputMethodManager.Stub 


    // This list contains the pairs of InputMethodInfo and InputMethodSubtype.

    private final HashMap<InputMethodInfo, ArrayList<InputMethodSubtype>>

            mShortcutInputMethodsAndSubtypes =

                new HashMap<InputMethodInfo, ArrayList<InputMethodSubtype>>();

            mShortcutInputMethodsAndSubtypes = new HashMap<>();



    // Was the keyguard locked when this client became current?

    private boolean mCurClientInKeyguard;
@@ -540,7 +538,7 @@ public class InputMethodManagerService extends IInputMethodManager.Stub 
            final String imeId = entry.getKey();

            ArraySet<String> prevSubtypes = prevMap.get(imeId);

            if (prevSubtypes == null) {

                prevSubtypes = new ArraySet<String>(2);

                prevSubtypes = new ArraySet<>(2);

                prevMap.put(imeId, prevSubtypes);

            }

            prevSubtypes.addAll(entry.getValue());
@@ -559,16 +557,15 @@ public class InputMethodManagerService extends IInputMethodManager.Stub 
    static String buildInputMethodsAndSubtypesString(ArrayMap<String, ArraySet<String>> map) {

        // we want to use the canonical InputMethodSettings implementation,

        // so we convert data structures first.

        List<Pair<String, ArrayList<String>>> imeMap =

                new ArrayList<Pair<String, ArrayList<String>>>(4);

        List<Pair<String, ArrayList<String>>> imeMap = new ArrayList<>(4);

        for (ArrayMap.Entry<String, ArraySet<String>> entry : map.entrySet()) {

            final String imeName = entry.getKey();

            final ArraySet<String> subtypeSet = entry.getValue();

            final ArrayList<String> subtypes = new ArrayList<String>(2);

            final ArrayList<String> subtypes = new ArrayList<>(2);

            if (subtypeSet != null) {

                subtypes.addAll(subtypeSet);

            }

            imeMap.add(new Pair<String, ArrayList<String>>(imeName, subtypes));

            imeMap.add(new Pair<>(imeName, subtypes));

        }

        return InputMethodSettings.buildInputMethodsSettingString(imeMap);

    }
@@ -576,8 +573,7 @@ public class InputMethodManagerService extends IInputMethodManager.Stub 
    // TODO: Move this method to InputMethodUtils with adding unit tests.

    static ArrayMap<String, ArraySet<String>> parseInputMethodsAndSubtypesString(

            final String inputMethodsAndSubtypesString) {

        final ArrayMap<String, ArraySet<String>> imeMap =

                new ArrayMap<String, ArraySet<String>>();

        final ArrayMap<String, ArraySet<String>> imeMap = new ArrayMap<>();

        if (TextUtils.isEmpty(inputMethodsAndSubtypesString)) {

            return imeMap;

        }
@@ -591,7 +587,7 @@ public class InputMethodManagerService extends IInputMethodManager.Stub 
                        typeSplitter,

                        subtypeSplitter);

        for (Pair<String, ArrayList<String>> ime : allImeSettings) {

            ArraySet<String> subtypes = new ArraySet<String>();

            ArraySet<String> subtypes = new ArraySet<>();

            if (ime.second != null) {

                subtypes.addAll(ime.second);

            }
@@ -1166,7 +1162,7 @@ public class InputMethodManagerService extends IInputMethodManager.Stub 
            return Collections.emptyList();

        }

        synchronized (mMethodMap) {

            return new ArrayList<InputMethodInfo>(mMethodList);

            return new ArrayList<>(mMethodList);

        }

    }
@@ -1190,7 +1186,7 @@ public class InputMethodManagerService extends IInputMethodManager.Stub 
            boolean allowsImplicitlySelectedSubtypes) {

        // TODO: Make this work even for non-current users?

        if (!calledFromValidUser()) {

            return Collections.<InputMethodSubtype>emptyList();

            return Collections.emptyList();

        }

        synchronized (mMethodMap) {

            final InputMethodInfo imi;
@@ -1200,7 +1196,7 @@ public class InputMethodManagerService extends IInputMethodManager.Stub 
                imi = mMethodMap.get(imiId);

            }

            if (imi == null) {

                return Collections.<InputMethodSubtype>emptyList();

                return Collections.emptyList();

            }

            return mSettings.getEnabledInputMethodSubtypeListLocked(

                    mContext, imi, allowsImplicitlySelectedSubtypes);
@@ -3408,8 +3404,7 @@ public class InputMethodManagerService extends IInputMethodManager.Stub 
            }

        }

        if (mostApplicableIMI != null) {

            return new Pair<InputMethodInfo, InputMethodSubtype> (mostApplicableIMI,

                    mostApplicableSubtype);

            return new Pair<> (mostApplicableIMI, mostApplicableSubtype);

        } else {

            return null;

        }
@@ -3473,7 +3468,7 @@ public class InputMethodManagerService extends IInputMethodManager.Stub 
        if (mShortcutInputMethodsAndSubtypes.containsKey(imi)) {

            mShortcutInputMethodsAndSubtypes.get(imi).add(subtype);

        } else {

            ArrayList<InputMethodSubtype> subtypes = new ArrayList<InputMethodSubtype>();

            ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();

            subtypes.add(subtype);

            mShortcutInputMethodsAndSubtypes.put(imi, subtypes);

        }
@@ -3484,7 +3479,7 @@ public class InputMethodManagerService extends IInputMethodManager.Stub 
    @Override

    public List getShortcutInputMethodsAndSubtypes() {

        synchronized (mMethodMap) {

            ArrayList<Object> ret = new ArrayList<Object>();

            ArrayList<Object> ret = new ArrayList<>();

            if (mShortcutInputMethodsAndSubtypes.size() == 0) {

                // If there are no selected shortcut subtypes, the framework will try to find

                // the most applicable subtype from all subtypes whose mode is
@@ -3545,7 +3540,7 @@ public class InputMethodManagerService extends IInputMethodManager.Stub 
        private final AtomicFile mAdditionalInputMethodSubtypeFile;

        private final HashMap<String, InputMethodInfo> mMethodMap;

        private final HashMap<String, List<InputMethodSubtype>> mAdditionalSubtypesMap =

                new HashMap<String, List<InputMethodSubtype>>();

                new HashMap<>();

        public InputMethodFileManager(HashMap<String, InputMethodInfo> methodMap, int userId) {

            if (methodMap == null) {

                throw new NullPointerException("methodMap is null");
@@ -3581,7 +3576,7 @@ public class InputMethodManagerService extends IInputMethodManager.Stub 
        public void addInputMethodSubtypes(

                InputMethodInfo imi, InputMethodSubtype[] additionalSubtypes) {

            synchronized (mMethodMap) {

                final ArrayList<InputMethodSubtype> subtypes = new ArrayList<InputMethodSubtype>();

                final ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();

                final int N = additionalSubtypes.length;

                for (int i = 0; i < N; ++i) {

                    final InputMethodSubtype subtype = additionalSubtypes[i];
@@ -3682,7 +3677,7 @@ public class InputMethodManagerService extends IInputMethodManager.Stub 
                            Slog.w(TAG, "Invalid imi id found in subtypes.xml");

                            continue;

                        }

                        tempSubtypesArray = new ArrayList<InputMethodSubtype>();

                        tempSubtypesArray = new ArrayList<>();

                        allSubtypes.put(currentImiId, tempSubtypesArray);

                    } else if (NODE_SUBTYPE.equals(nodeName)) {

                        if (TextUtils.isEmpty(currentImiId) || tempSubtypesArray == null) {