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

Commit 235f202a authored by Danny Baumann's avatar Danny Baumann
Browse files

Cleanup and improve ringer tile code. 

Handle absence of vibrator properly by excluding the respective modes
from the selection in that case.

Change-Id: I63d1fc06cbbcadadff51866b929dde453f4eb4bd
parent c5fada38

packages/SystemUI/src/com/android/systemui/quicksettings/RingerModeTile.java

+70 −102
Original line number Diff line number Diff line
@@ -9,39 +9,35 @@ import android.os.UserHandle; 
import android.os.Vibrator;

import android.provider.Settings;

import android.text.TextUtils;

import android.view.LayoutInflater;

import android.view.View;

import android.view.View.OnLongClickListener;



import com.android.systemui.R;

import com.android.systemui.statusbar.phone.QuickSettingsController;

import com.android.systemui.statusbar.phone.QuickSettingsContainerView;



public class RingerModeTile extends QuickSettingsTile {

import java.util.ArrayList;



public class RingerModeTile extends QuickSettingsTile {

    private static final String SEPARATOR = "OV=I=XseparatorX=I=VO";



    // Define the available ringer modes

    private final Ringer mSilentRinger = new Ringer(AudioManager.RINGER_MODE_SILENT, false);

    private final Ringer mVibrateRinger = new Ringer(AudioManager.RINGER_MODE_VIBRATE, true);

    private final Ringer mSoundRinger = new Ringer(AudioManager.RINGER_MODE_NORMAL, false);

    private final Ringer mSoundVibrateRinger = new Ringer(AudioManager.RINGER_MODE_NORMAL, true);

    private final Ringer[] mRingers = new Ringer[] {

            mSilentRinger, mVibrateRinger, mSoundRinger, mSoundVibrateRinger

    private static final Ringer[] RINGERS = new Ringer[] {

        new Ringer(AudioManager.RINGER_MODE_SILENT, false, R.drawable.ic_qs_ring_off),

        new Ringer(AudioManager.RINGER_MODE_VIBRATE, true, R.drawable.ic_qs_vibrate_on),

        new Ringer(AudioManager.RINGER_MODE_NORMAL, false, R.drawable.ic_qs_ring_on),

        new Ringer(AudioManager.RINGER_MODE_NORMAL, true, R.drawable.ic_qs_ring_vibrate_on)

    };



    private int mRingersIndex;

    private int[] mRingerValues = new int[] {

            0, 1, 2, 3

    };

    private int mRingerValuesIndex;

    private ArrayList<Ringer> mRingers;

    private int mRingerIndex;



    private AudioManager mAudioManager;

    private Vibrator mVibrator;



    public RingerModeTile(Context context, QuickSettingsController qsc) {

        super(context, qsc);



        mRingers = new ArrayList<Ringer>();

        mAudioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);

        mVibrator = (Vibrator) mContext.getSystemService(Context.VIBRATOR_SERVICE);



        // Tile actions

        mOnClick = new View.OnClickListener() {
@@ -52,7 +48,7 @@ public class RingerModeTile extends QuickSettingsTile { 
            }

        };



        mOnLongClick = new OnLongClickListener() {

        mOnLongClick = new View.OnLongClickListener() {

            @Override

            public boolean onLongClick(View v) {

                startSettingsActivity(android.provider.Settings.ACTION_SOUND_SETTINGS);
@@ -60,10 +56,10 @@ public class RingerModeTile extends QuickSettingsTile { 
            }

        };

        qsc.registerAction(AudioManager.RINGER_MODE_CHANGED_ACTION, this);

        qsc.registerObservedContent(Settings.System.getUriFor(Settings.System.EXPANDED_RING_MODE)

                , this);

        qsc.registerObservedContent(Settings.System.getUriFor(Settings.System.VIBRATE_WHEN_RINGING)

                , this);

        qsc.registerObservedContent(

                Settings.System.getUriFor(Settings.System.EXPANDED_RING_MODE), this);

        qsc.registerObservedContent(

                Settings.System.getUriFor(Settings.System.VIBRATE_WHEN_RINGING), this);

    }



    @Override
@@ -73,14 +69,14 @@ public class RingerModeTile extends QuickSettingsTile { 


    @Override

    public void onChangeUri(ContentResolver resolver, Uri uri) {

        updateSettings(mContext.getContentResolver());

        updateSettings();

        updateResources();

    }



    @Override

    void onPostCreate() {

        // Load the available ringer modes

        updateSettings(mContext.getContentResolver());

        updateSettings();



        // Make sure we show the initial state correctly

        updateTile();
@@ -94,125 +90,97 @@ public class RingerModeTile extends QuickSettingsTile { 
        super.updateResources();

    }



    private synchronized void updateTile() {

    private void updateTile() {

        // The title does not change

        mLabel = mContext.getString(R.string.quick_settings_ringer_normal);



        // The icon will change depending on index

        findCurrentState();

        switch (mRingersIndex) {

            case 0:

                mDrawable = R.drawable.ic_qs_ring_off;

                break;

            case 1:

                mDrawable = R.drawable.ic_qs_vibrate_on;

                break;

            case 2:

                mDrawable = R.drawable.ic_qs_ring_on;

                break;

            case 3:

                mDrawable = R.drawable.ic_qs_ring_vibrate_on;

                break;

        }



        for (int i = 0; i < mRingerValues.length; i++) {

            if (mRingersIndex == mRingerValues[i]) {

                mRingerValuesIndex = i;

                break;

            }

        }

        mDrawable = mRingers.get(mRingerIndex).mDrawable;

    }



    protected void toggleState() {

        mRingerValuesIndex++;

        if (mRingerValuesIndex > mRingerValues.length - 1) {

            mRingerValuesIndex = 0;

        mRingerIndex++;

        if (mRingerIndex >= mRingers.size()) {

            mRingerIndex = 0;

        }



        mRingersIndex = mRingerValues[mRingerValuesIndex];

        if (mRingersIndex > mRingers.length - 1) {

            mRingersIndex = 0;

        Ringer r = mRingers.get(mRingerIndex);



        // If we are setting a vibrating state, vibrate to indicate it

        if (r.mVibrateWhenRinging) {

            mVibrator.vibrate(250);

        }



        Ringer ringer = mRingers[mRingersIndex];

        ringer.execute(mContext);

        // Set the desired state

        ContentResolver resolver = mContext.getContentResolver();

        Settings.System.putIntForUser(resolver, Settings.System.VIBRATE_WHEN_RINGING,

                r.mVibrateWhenRinging ? 1 : 0, UserHandle.USER_CURRENT);

        mAudioManager.setRingerMode(r.mRingerMode);

    }



    public String[] parseStoredValue(CharSequence val) {

        if (TextUtils.isEmpty(val)) {

            return null;

        } else {

          return val.toString().split(SEPARATOR);

        }

        return val.toString().split(SEPARATOR);

    }



    private void updateSettings(ContentResolver resolver) {

        String[] modes = parseStoredValue(Settings.System.getStringForUser(

                resolver, Settings.System.EXPANDED_RING_MODE, UserHandle.USER_CURRENT));

    private void updateSettings() {

        String setting = Settings.System.getStringForUser(mContext.getContentResolver(),

                Settings.System.EXPANDED_RING_MODE, UserHandle.USER_CURRENT);

        String[] modes = parseStoredValue(setting);

        Vibrator vibrator = (Vibrator) mContext.getSystemService(Context.VIBRATOR_SERVICE);

        boolean hasVibrator = vibrator.hasVibrator();



        mRingers.clear();



        if (modes == null || modes.length == 0) {

            mRingerValues = new int[] {

                    0, 1, 2, 3

            };

            for (Ringer r : RINGERS) {

                if (hasVibrator || !r.mVibrateWhenRinging) {

                    mRingers.add(r);

                }

            }

        } else {

            mRingerValues = new int[modes.length];

            for (int i = 0; i < modes.length; i++) {

                mRingerValues[i] = Integer.valueOf(modes[i]);

                int index = Integer.valueOf(modes[i]);

                Ringer r = index < RINGERS.length ? RINGERS[index] : null;



                if (r != null && (hasVibrator || !r.mVibrateWhenRinging)) {

                    mRingers.add(r);

                }

            }

        }

        if (mRingers.isEmpty()) {

            mRingers.add(RINGERS[0]);

        }

    }



    private void findCurrentState() {

        ContentResolver resolver = mContext.getContentResolver();

        boolean vibrateWhenRinging = Settings.System.getIntForUser(resolver,

        boolean vibrateWhenRinging = Settings.System.getIntForUser(mContext.getContentResolver(),

                Settings.System.VIBRATE_WHEN_RINGING, 0, UserHandle.USER_CURRENT) == 1;

        int ringerMode = mAudioManager.getRingerMode();



        Ringer ringer = new Ringer(ringerMode, vibrateWhenRinging);

        for (int i = 0; i < mRingers.length; i++) {

            if (mRingers[i].equals(ringer)) {

                mRingersIndex = i;

        mRingerIndex = 0;



        for (int i = 0; i < mRingers.size(); i++) {

            Ringer r = mRingers.get(i);

            if (ringerMode == r.mRingerMode && vibrateWhenRinging == r.mVibrateWhenRinging) {

                mRingerIndex = i;

                break;

            }

        }

    }



    private class Ringer {

    private static class Ringer {

        final boolean mVibrateWhenRinging;

        final int mRingerMode;

        final int mDrawable;



        Ringer( int ringerMode, boolean vibrateWhenRinging) {

        Ringer(int ringerMode, boolean vibrateWhenRinging, int drawable) {

            mVibrateWhenRinging = vibrateWhenRinging;

            mRingerMode = ringerMode;

        }



        void execute(Context context) {

            // If we are setting a vibrating state, vibrate to indicate it

            if (mVibrateWhenRinging) {

                Vibrator vibrator = (Vibrator) mContext.getSystemService(Context.VIBRATOR_SERVICE);

                vibrator.vibrate(250);

            }



            // Set the desired state

            ContentResolver resolver = context.getContentResolver();

            Settings.System.putIntForUser(resolver, Settings.System.VIBRATE_WHEN_RINGING,

                    mVibrateWhenRinging ? 1 : 0, UserHandle.USER_CURRENT);

            mAudioManager.setRingerMode(mRingerMode);

        }



        @Override

        public boolean equals(Object o) {

            if (o == null) {

                return false;

            }

            if (o.getClass() != getClass()) {

                return false;

            }

            Ringer r = (Ringer) o;

            if ((mRingerMode == AudioManager.RINGER_MODE_SILENT || mRingerMode == AudioManager.RINGER_MODE_VIBRATE)

                    && (r.mRingerMode == mRingerMode))

                return true;

            return r.mVibrateWhenRinging == mVibrateWhenRinging

                    && r.mRingerMode == mRingerMode;

            mDrawable = drawable;

        }

    }

}