Merge "Cleanup and improve ringer tile code." into cm-10.2 (913f365d) · Commits · e / os / android_frameworks_base

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;
		}
		}
		}