From 8872c23e739de38d74f04a8c852ebb5199c905f6 Mon Sep 17 00:00:00 2001 From: Michael Kolb Date: Tue, 29 Jan 2013 10:33:22 -0800 Subject: Move Camera Java/Native source into Gallery2 Change-Id: I968efe4d656e88a7760d3c0044f65b4adac2ddd1 --- src/com/android/camera/ListPreference.java | 181 +++++++++++++++++++++++++++++ 1 file changed, 181 insertions(+) create mode 100644 src/com/android/camera/ListPreference.java (limited to 'src/com/android/camera/ListPreference.java') diff --git a/src/com/android/camera/ListPreference.java b/src/com/android/camera/ListPreference.java new file mode 100644 index 000000000..17266ea73 --- /dev/null +++ b/src/com/android/camera/ListPreference.java @@ -0,0 +1,181 @@ +/* + * Copyright (C) 2009 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.camera; + +import android.content.Context; +import android.content.SharedPreferences; +import android.content.res.TypedArray; +import android.util.AttributeSet; +import android.util.Log; +import android.util.TypedValue; + +import java.util.ArrayList; +import java.util.List; + +/** + * A type of CameraPreference whose number of possible values + * is limited. + */ +public class ListPreference extends CameraPreference { + private static final String TAG = "ListPreference"; + private final String mKey; + private String mValue; + private final CharSequence[] mDefaultValues; + + private CharSequence[] mEntries; + private CharSequence[] mEntryValues; + private boolean mLoaded = false; + + public ListPreference(Context context, AttributeSet attrs) { + super(context, attrs); + + TypedArray a = context.obtainStyledAttributes( + attrs, R.styleable.ListPreference, 0, 0); + + mKey = Util.checkNotNull( + a.getString(R.styleable.ListPreference_key)); + + // We allow the defaultValue attribute to be a string or an array of + // strings. The reason we need multiple default values is that some + // of them may be unsupported on a specific platform (for example, + // continuous auto-focus). In that case the first supported value + // in the array will be used. + int attrDefaultValue = R.styleable.ListPreference_defaultValue; + TypedValue tv = a.peekValue(attrDefaultValue); + if (tv != null && tv.type == TypedValue.TYPE_REFERENCE) { + mDefaultValues = a.getTextArray(attrDefaultValue); + } else { + mDefaultValues = new CharSequence[1]; + mDefaultValues[0] = a.getString(attrDefaultValue); + } + + setEntries(a.getTextArray(R.styleable.ListPreference_entries)); + setEntryValues(a.getTextArray( + R.styleable.ListPreference_entryValues)); + a.recycle(); + } + + public String getKey() { + return mKey; + } + + public CharSequence[] getEntries() { + return mEntries; + } + + public CharSequence[] getEntryValues() { + return mEntryValues; + } + + public void setEntries(CharSequence entries[]) { + mEntries = entries == null ? new CharSequence[0] : entries; + } + + public void setEntryValues(CharSequence values[]) { + mEntryValues = values == null ? new CharSequence[0] : values; + } + + public String getValue() { + if (!mLoaded) { + mValue = getSharedPreferences().getString(mKey, + findSupportedDefaultValue()); + mLoaded = true; + } + return mValue; + } + + // Find the first value in mDefaultValues which is supported. + private String findSupportedDefaultValue() { + for (int i = 0; i < mDefaultValues.length; i++) { + for (int j = 0; j < mEntryValues.length; j++) { + // Note that mDefaultValues[i] may be null (if unspecified + // in the xml file). + if (mEntryValues[j].equals(mDefaultValues[i])) { + return mDefaultValues[i].toString(); + } + } + } + return null; + } + + public void setValue(String value) { + if (findIndexOfValue(value) < 0) throw new IllegalArgumentException(); + mValue = value; + persistStringValue(value); + } + + public void setValueIndex(int index) { + setValue(mEntryValues[index].toString()); + } + + public int findIndexOfValue(String value) { + for (int i = 0, n = mEntryValues.length; i < n; ++i) { + if (Util.equals(mEntryValues[i], value)) return i; + } + return -1; + } + + public String getEntry() { + return mEntries[findIndexOfValue(getValue())].toString(); + } + + protected void persistStringValue(String value) { + SharedPreferences.Editor editor = getSharedPreferences().edit(); + editor.putString(mKey, value); + editor.apply(); + } + + @Override + public void reloadValue() { + this.mLoaded = false; + } + + public void filterUnsupported(List supported) { + ArrayList entries = new ArrayList(); + ArrayList entryValues = new ArrayList(); + for (int i = 0, len = mEntryValues.length; i < len; i++) { + if (supported.indexOf(mEntryValues[i].toString()) >= 0) { + entries.add(mEntries[i]); + entryValues.add(mEntryValues[i]); + } + } + int size = entries.size(); + mEntries = entries.toArray(new CharSequence[size]); + mEntryValues = entryValues.toArray(new CharSequence[size]); + } + + public void filterDuplicated() { + ArrayList entries = new ArrayList(); + ArrayList entryValues = new ArrayList(); + for (int i = 0, len = mEntryValues.length; i < len; i++) { + if (!entries.contains(mEntries[i])) { + entries.add(mEntries[i]); + entryValues.add(mEntryValues[i]); + } + } + int size = entries.size(); + mEntries = entries.toArray(new CharSequence[size]); + mEntryValues = entryValues.toArray(new CharSequence[size]); + } + + public void print() { + Log.v(TAG, "Preference key=" + getKey() + ". value=" + getValue()); + for (int i = 0; i < mEntryValues.length; i++) { + Log.v(TAG, "entryValues[" + i + "]=" + mEntryValues[i]); + } + } +} -- cgit v1.2.3