src/com/android/camera/settings/CameraSettingsActivity.java - platform/packages/apps/Camera2 - Git at Google

 /*
  * Copyright (C) 2014 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.settings;

 import android.app.ActionBar;
 import android.app.Activity;
 import android.content.Context;
 import android.content.Intent;
 import android.content.SharedPreferences;
 import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
 import android.os.Bundle;
 import android.preference.ListPreference;
 import android.preference.Preference;
 import android.preference.Preference.OnPreferenceClickListener;
 import android.preference.PreferenceFragment;
 import android.preference.PreferenceGroup;
 import android.preference.PreferenceScreen;
 import android.support.v4.app.FragmentActivity;
 import android.view.MenuItem;

 import com.android.camera.FatalErrorHandler;
 import com.android.camera.FatalErrorHandlerImpl;
 import com.android.camera.debug.Log;
 import com.android.camera.device.CameraId;
 import com.android.camera.one.OneCamera.Facing;
 import com.android.camera.one.OneCameraAccessException;
 import com.android.camera.one.OneCameraCharacteristics;
 import com.android.camera.one.OneCameraException;
 import com.android.camera.one.OneCameraManager;
 import com.android.camera.one.OneCameraModule;
 import com.android.camera.settings.PictureSizeLoader.PictureSizes;
 import com.android.camera.settings.SettingsUtil.SelectedVideoQualities;
 import com.android.camera.util.CameraSettingsActivityHelper;
 import com.android.camera.util.GoogleHelpHelper;
 import com.android.camera.util.Size;
 import com.android.camera2.R;
 import com.android.ex.camera2.portability.CameraAgentFactory;
 import com.android.ex.camera2.portability.CameraDeviceInfo;

 import java.text.DecimalFormat;
 import java.util.ArrayList;
 import java.util.List;

 /**
  * Provides the settings UI for the Camera app.
  */
 public class CameraSettingsActivity extends FragmentActivity {

     /**
      * Used to denote a subsection of the preference tree to display in the
      * Fragment. For instance, if 'Advanced' key is provided, the advanced
      * preference section will be treated as the root for display. This is used
      * to enable activity transitions between preference sections, and allows
      * back/up stack to operate correctly.
      */
     public static final String PREF_SCREEN_EXTRA = "pref_screen_extra";
     public static final String HIDE_ADVANCED_SCREEN = "hide_advanced";
     private OneCameraManager mOneCameraManager;

     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);

         FatalErrorHandler fatalErrorHandler = new FatalErrorHandlerImpl(this);
         boolean hideAdvancedScreen = false;

         try {
             mOneCameraManager = OneCameraModule.provideOneCameraManager();
         } catch (OneCameraException e) {
             // Log error and continue. Modules requiring OneCamera should check
             // and handle if null by showing error dialog or other treatment.
             fatalErrorHandler.onGenericCameraAccessFailure();
         }

         // Check if manual exposure is available, so we can decide whether to
         // display Advanced screen.
         try {
             CameraId frontCameraId = mOneCameraManager.findFirstCameraFacing(Facing.FRONT);
             CameraId backCameraId = mOneCameraManager.findFirstCameraFacing(Facing.BACK);

             // The exposure compensation is supported when both of the following conditions meet
             //   - we have the valid camera, and
             //   - the valid camera supports the exposure compensation
             boolean isExposureCompensationSupportedByFrontCamera = (frontCameraId != null) &&
                     (mOneCameraManager.getOneCameraCharacteristics(frontCameraId)
                             .isExposureCompensationSupported());
             boolean isExposureCompensationSupportedByBackCamera = (backCameraId != null) &&
                     (mOneCameraManager.getOneCameraCharacteristics(backCameraId)
                             .isExposureCompensationSupported());

             // Hides the option if neither front and back camera support exposure compensation.
             if (!isExposureCompensationSupportedByFrontCamera &&
                     !isExposureCompensationSupportedByBackCamera) {
                 hideAdvancedScreen = true;
             }
         } catch (OneCameraAccessException e) {
             fatalErrorHandler.onGenericCameraAccessFailure();
         }

         ActionBar actionBar = getActionBar();
         actionBar.setDisplayHomeAsUpEnabled(true);
         actionBar.setTitle(R.string.mode_settings);

         String prefKey = getIntent().getStringExtra(PREF_SCREEN_EXTRA);
         CameraSettingsFragment dialog = new CameraSettingsFragment();
         Bundle bundle = new Bundle(1);
         bundle.putString(PREF_SCREEN_EXTRA, prefKey);
         bundle.putBoolean(HIDE_ADVANCED_SCREEN, hideAdvancedScreen);
         dialog.setArguments(bundle);
         getFragmentManager().beginTransaction().replace(android.R.id.content, dialog).commit();
     }

     @Override
     public boolean onMenuItemSelected(int featureId, MenuItem item) {
         int itemId = item.getItemId();
         if (itemId == android.R.id.home) {
             finish();
             return true;
         }
         return true;
     }

     public static class CameraSettingsFragment extends PreferenceFragment implements
             OnSharedPreferenceChangeListener {

         public static final String PREF_CATEGORY_RESOLUTION = "pref_category_resolution";
         public static final String PREF_CATEGORY_ADVANCED = "pref_category_advanced";
         public static final String PREF_LAUNCH_HELP = "pref_launch_help";
         private static final Log.Tag TAG = new Log.Tag("SettingsFragment");
         private static DecimalFormat sMegaPixelFormat = new DecimalFormat("##0.0");
         private String[] mCamcorderProfileNames;
         private CameraDeviceInfo mInfos;
         private String mPrefKey;
         private boolean mHideAdvancedScreen;
         private boolean mGetSubPrefAsRoot = true;

         // Selected resolutions for the different cameras and sizes.
         private PictureSizes mPictureSizes;

         @Override
         public void onCreate(Bundle savedInstanceState) {
             super.onCreate(savedInstanceState);
             Bundle arguments = getArguments();
             if (arguments != null) {
                 mPrefKey = arguments.getString(PREF_SCREEN_EXTRA);
                 mHideAdvancedScreen = arguments.getBoolean(HIDE_ADVANCED_SCREEN);
             }
             Context context = this.getActivity().getApplicationContext();
             addPreferencesFromResource(R.xml.camera_preferences);
             PreferenceScreen advancedScreen =
                     (PreferenceScreen) findPreference(PREF_CATEGORY_ADVANCED);

             // If manual exposure not enabled, hide the Advanced screen.
             if (mHideAdvancedScreen) {
                 PreferenceScreen root = (PreferenceScreen) findPreference("prefscreen_top");
                 root.removePreference(advancedScreen);
             }

             // Allow the Helper to edit the full preference hierarchy, not the
             // sub tree we may show as root. See {@link #getPreferenceScreen()}.
             mGetSubPrefAsRoot = false;
             CameraSettingsActivityHelper.addAdditionalPreferences(this, context);
             mGetSubPrefAsRoot = true;

             mCamcorderProfileNames = getResources().getStringArray(R.array.camcorder_profile_names);
             mInfos = CameraAgentFactory
                     .getAndroidCameraAgent(context, CameraAgentFactory.CameraApi.API_1)
                     .getCameraDeviceInfo();
             CameraAgentFactory.recycle(CameraAgentFactory.CameraApi.API_1);
         }

         @Override
         public void onResume() {
             super.onResume();
             final Activity activity = this.getActivity();

             // Load the camera sizes.
             loadSizes();

             // Send loaded sizes to additional preferences.
             CameraSettingsActivityHelper.onSizesLoaded(this, mPictureSizes.backCameraSizes,
                     new ListPreferenceFiller() {
                         @Override
                         public void fill(List<Size> sizes, ListPreference preference) {
                             setEntriesForSelection(sizes, preference);
                         }
                     });

             // Make sure to hide settings for cameras that don't exist on this
             // device.
             setVisibilities();

             // Put in the summaries for the currently set values.
             final PreferenceScreen resolutionScreen =
                     (PreferenceScreen) findPreference(PREF_CATEGORY_RESOLUTION);
             fillEntriesAndSummaries(resolutionScreen);
             setPreferenceScreenIntent(resolutionScreen);

             final PreferenceScreen advancedScreen =
                     (PreferenceScreen) findPreference(PREF_CATEGORY_ADVANCED);

             if (!mHideAdvancedScreen) {
                 setPreferenceScreenIntent(advancedScreen);
             }

             Preference helpPref = findPreference(PREF_LAUNCH_HELP);
             helpPref.setOnPreferenceClickListener(
                     new OnPreferenceClickListener() {
                         @Override
                         public boolean onPreferenceClick(Preference preference) {
                             new GoogleHelpHelper(activity).launchGoogleHelp();
                             return true;
                         }
                     });
             getPreferenceScreen().getSharedPreferences()
                     .registerOnSharedPreferenceChangeListener(this);
         }

         /**
          * Configure home-as-up for sub-screens.
          */
         private void setPreferenceScreenIntent(final PreferenceScreen preferenceScreen) {
             Intent intent = new Intent(getActivity(), CameraSettingsActivity.class);
             intent.putExtra(PREF_SCREEN_EXTRA, preferenceScreen.getKey());
             preferenceScreen.setIntent(intent);
         }

         /**
          * This override allows the CameraSettingsFragment to be reused for
          * different nested PreferenceScreens within the single camera
          * preferences XML resource. If the fragment is constructed with a
          * desired preference key (delivered via an extra in the creation
          * intent), it is used to look up the nested PreferenceScreen and
          * returned here.
          */
         @Override
         public PreferenceScreen getPreferenceScreen() {
             PreferenceScreen root = super.getPreferenceScreen();
             if (!mGetSubPrefAsRoot || mPrefKey == null || root == null) {
                 return root;
             } else {
                 PreferenceScreen match = findByKey(root, mPrefKey);
                 if (match != null) {
                     return match;
                 } else {
                     throw new RuntimeException("key " + mPrefKey + " not found");
                 }
             }
         }

         private PreferenceScreen findByKey(PreferenceScreen parent, String key) {
             if (key.equals(parent.getKey())) {
                 return parent;
             } else {
                 for (int i = 0; i < parent.getPreferenceCount(); i++) {
                     Preference child = parent.getPreference(i);
                     if (child instanceof PreferenceScreen) {
                         PreferenceScreen match = findByKey((PreferenceScreen) child, key);
                         if (match != null) {
                             return match;
                         }
                     }
                 }
                 return null;
             }
         }

         /**
          * Depending on camera availability on the device, this removes settings
          * for cameras the device doesn't have.
          */
         private void setVisibilities() {
             PreferenceGroup resolutions =
                     (PreferenceGroup) findPreference(PREF_CATEGORY_RESOLUTION);
             if (mPictureSizes.backCameraSizes.isEmpty()) {
                 recursiveDelete(resolutions,
                         findPreference(Keys.KEY_PICTURE_SIZE_BACK));
                 recursiveDelete(resolutions,
                         findPreference(Keys.KEY_VIDEO_QUALITY_BACK));
             }
             if (mPictureSizes.frontCameraSizes.isEmpty()) {
                 recursiveDelete(resolutions,
                         findPreference(Keys.KEY_PICTURE_SIZE_FRONT));
                 recursiveDelete(resolutions,
                         findPreference(Keys.KEY_VIDEO_QUALITY_FRONT));
             }
         }

         /**
          * Recursively go through settings and fill entries and summaries of our
          * preferences.
          */
         private void fillEntriesAndSummaries(PreferenceGroup group) {
             for (int i = 0; i < group.getPreferenceCount(); ++i) {
                 Preference pref = group.getPreference(i);
                 if (pref instanceof PreferenceGroup) {
                     fillEntriesAndSummaries((PreferenceGroup) pref);
                 }
                 setSummary(pref);
                 setEntries(pref);
             }
         }

         /**
          * Recursively traverses the tree from the given group as the route and
          * tries to delete the preference. Traversal stops once the preference
          * was found and removed.
          */
         private boolean recursiveDelete(PreferenceGroup group, Preference preference) {
             if (group == null) {
                 Log.d(TAG, "attempting to delete from null preference group");
                 return false;
             }
             if (preference == null) {
                 Log.d(TAG, "attempting to delete null preference");
                 return false;
             }
             if (group.removePreference(preference)) {
                 // Removal was successful.
                 return true;
             }

             for (int i = 0; i < group.getPreferenceCount(); ++i) {
                 Preference pref = group.getPreference(i);
                 if (pref instanceof PreferenceGroup) {
                     if (recursiveDelete((PreferenceGroup) pref, preference)) {
                         return true;
                     }
                 }
             }
             return false;
         }

         @Override
         public void onPause() {
             super.onPause();
             getPreferenceScreen().getSharedPreferences()
                     .unregisterOnSharedPreferenceChangeListener(this);
         }

         @Override
         public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
             setSummary(findPreference(key));
         }

         /**
          * Set the entries for the given preference. The given preference needs
          * to be a {@link ListPreference}
          */
         private void setEntries(Preference preference) {
             if (!(preference instanceof ListPreference)) {
                 return;
             }

             ListPreference listPreference = (ListPreference) preference;
             if (listPreference.getKey().equals(Keys.KEY_PICTURE_SIZE_BACK)) {
                 setEntriesForSelection(mPictureSizes.backCameraSizes, listPreference);
             } else if (listPreference.getKey().equals(Keys.KEY_PICTURE_SIZE_FRONT)) {
                 setEntriesForSelection(mPictureSizes.frontCameraSizes, listPreference);
             } else if (listPreference.getKey().equals(Keys.KEY_VIDEO_QUALITY_BACK)) {
                 setEntriesForSelection(mPictureSizes.videoQualitiesBack.orNull(), listPreference);
             } else if (listPreference.getKey().equals(Keys.KEY_VIDEO_QUALITY_FRONT)) {
                 setEntriesForSelection(mPictureSizes.videoQualitiesFront.orNull(), listPreference);
             }
         }

         /**
          * Set the summary for the given preference. The given preference needs
          * to be a {@link ListPreference}.
          */
         private void setSummary(Preference preference) {
             if (!(preference instanceof ListPreference)) {
                 return;
             }

             ListPreference listPreference = (ListPreference) preference;
             if (listPreference.getKey().equals(Keys.KEY_PICTURE_SIZE_BACK)) {
                 setSummaryForSelection(mPictureSizes.backCameraSizes,
                         listPreference);
             } else if (listPreference.getKey().equals(Keys.KEY_PICTURE_SIZE_FRONT)) {
                 setSummaryForSelection(mPictureSizes.frontCameraSizes,
                         listPreference);
             } else if (listPreference.getKey().equals(Keys.KEY_VIDEO_QUALITY_BACK)) {
                 setSummaryForSelection(mPictureSizes.videoQualitiesBack.orNull(), listPreference);
             } else if (listPreference.getKey().equals(Keys.KEY_VIDEO_QUALITY_FRONT)) {
                 setSummaryForSelection(mPictureSizes.videoQualitiesFront.orNull(), listPreference);
             } else {
                 listPreference.setSummary(listPreference.getEntry());
             }
         }

         /**
          * Sets the entries for the given list preference.
          *
          * @param selectedSizes The possible S,M,L entries the user can choose
          *            from.
          * @param preference The preference to set the entries for.
          */
         private void setEntriesForSelection(List<Size> selectedSizes,
                 ListPreference preference) {
             if (selectedSizes == null) {
                 return;
             }

             String[] entries = new String[selectedSizes.size()];
             String[] entryValues = new String[selectedSizes.size()];
             for (int i = 0; i < selectedSizes.size(); i++) {
                 Size size = selectedSizes.get(i);
                 entries[i] = getSizeSummaryString(size);
                 entryValues[i] = SettingsUtil.sizeToSettingString(size);
             }
             preference.setEntries(entries);
             preference.setEntryValues(entryValues);
         }

         /**
          * Sets the entries for the given list preference.
          *
          * @param selectedQualities The possible S,M,L entries the user can
          *            choose from.
          * @param preference The preference to set the entries for.
          */
         private void setEntriesForSelection(SelectedVideoQualities selectedQualities,
                 ListPreference preference) {
             if (selectedQualities == null) {
                 return;
             }

             // Avoid adding double entries at the bottom of the list which
             // indicates that not at least 3 qualities are supported.
             ArrayList<String> entries = new ArrayList<String>();
             entries.add(mCamcorderProfileNames[selectedQualities.large]);
             if (selectedQualities.medium != selectedQualities.large) {
                 entries.add(mCamcorderProfileNames[selectedQualities.medium]);
             }
             if (selectedQualities.small != selectedQualities.medium) {
                 entries.add(mCamcorderProfileNames[selectedQualities.small]);
             }
             preference.setEntries(entries.toArray(new String[0]));
         }

         /**
          * Sets the summary for the given list preference.
          *
          * @param displayableSizes The human readable preferred sizes
          * @param preference The preference for which to set the summary.
          */
         private void setSummaryForSelection(List<Size> displayableSizes,
                                             ListPreference preference) {
             String setting = preference.getValue();
             if (setting == null || !setting.contains("x")) {
                 return;
             }
             Size settingSize = SettingsUtil.sizeFromSettingString(setting);
             if (settingSize == null || settingSize.area() == 0) {
                 return;
             }
             preference.setSummary(getSizeSummaryString(settingSize));
         }

         /**
          * Sets the summary for the given list preference.
          *
          * @param selectedQualities The selected video qualities.
          * @param preference The preference for which to set the summary.
          */
         private void setSummaryForSelection(SelectedVideoQualities selectedQualities,
                 ListPreference preference) {
             if (selectedQualities == null) {
                 return;
             }

             int selectedQuality = selectedQualities.getFromSetting(preference.getValue());
             preference.setSummary(mCamcorderProfileNames[selectedQuality]);
         }

         /**
          * This method gets the selected picture sizes for S,M,L and populates
          * {@link #mPictureSizes} accordingly.
          */
         private void loadSizes() {
             if (mInfos == null) {
                 Log.w(TAG, "null deviceInfo, cannot display resolution sizes");
                 return;
             }
             PictureSizeLoader loader = new PictureSizeLoader(getActivity().getApplicationContext());
             mPictureSizes = loader.computePictureSizes();
             loader.release();
         }

         /**
          * @param size The photo resolution.
          * @return A human readable and translated string for labeling the
          *         picture size in megapixels.
          */
         private String getSizeSummaryString(Size size) {
             Size approximateSize = ResolutionUtil.getApproximateSize(size);
             String megaPixels = sMegaPixelFormat.format((size.width() * size.height()) / 1e6);
             int numerator = ResolutionUtil.aspectRatioNumerator(approximateSize);
             int denominator = ResolutionUtil.aspectRatioDenominator(approximateSize);
             String result = getResources().getString(
                     R.string.setting_summary_aspect_ratio_and_megapixels, numerator, denominator,
                     megaPixels);
             return result;
         }
     }
 }
	/*
	* Copyright (C) 2014 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.settings;

	import android.app.ActionBar;
	import android.app.Activity;
	import android.content.Context;
	import android.content.Intent;
	import android.content.SharedPreferences;
	import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
	import android.os.Bundle;
	import android.preference.ListPreference;
	import android.preference.Preference;
	import android.preference.Preference.OnPreferenceClickListener;
	import android.preference.PreferenceFragment;
	import android.preference.PreferenceGroup;
	import android.preference.PreferenceScreen;
	import android.support.v4.app.FragmentActivity;
	import android.view.MenuItem;

	import com.android.camera.FatalErrorHandler;
	import com.android.camera.FatalErrorHandlerImpl;
	import com.android.camera.debug.Log;
	import com.android.camera.device.CameraId;
	import com.android.camera.one.OneCamera.Facing;
	import com.android.camera.one.OneCameraAccessException;
	import com.android.camera.one.OneCameraCharacteristics;
	import com.android.camera.one.OneCameraException;
	import com.android.camera.one.OneCameraManager;
	import com.android.camera.one.OneCameraModule;
	import com.android.camera.settings.PictureSizeLoader.PictureSizes;
	import com.android.camera.settings.SettingsUtil.SelectedVideoQualities;
	import com.android.camera.util.CameraSettingsActivityHelper;
	import com.android.camera.util.GoogleHelpHelper;
	import com.android.camera.util.Size;
	import com.android.camera2.R;
	import com.android.ex.camera2.portability.CameraAgentFactory;
	import com.android.ex.camera2.portability.CameraDeviceInfo;

	import java.text.DecimalFormat;
	import java.util.ArrayList;
	import java.util.List;

	/**
	* Provides the settings UI for the Camera app.
	*/
	public class CameraSettingsActivity extends FragmentActivity {

	/**
	* Used to denote a subsection of the preference tree to display in the
	* Fragment. For instance, if 'Advanced' key is provided, the advanced
	* preference section will be treated as the root for display. This is used
	* to enable activity transitions between preference sections, and allows
	* back/up stack to operate correctly.
	*/
	public static final String PREF_SCREEN_EXTRA = "pref_screen_extra";
	public static final String HIDE_ADVANCED_SCREEN = "hide_advanced";
	private OneCameraManager mOneCameraManager;

	@Override
	public void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);

	FatalErrorHandler fatalErrorHandler = new FatalErrorHandlerImpl(this);
	boolean hideAdvancedScreen = false;

	try {
	mOneCameraManager = OneCameraModule.provideOneCameraManager();
	} catch (OneCameraException e) {
	// Log error and continue. Modules requiring OneCamera should check
	// and handle if null by showing error dialog or other treatment.
	fatalErrorHandler.onGenericCameraAccessFailure();
	}

	// Check if manual exposure is available, so we can decide whether to
	// display Advanced screen.
	try {
	CameraId frontCameraId = mOneCameraManager.findFirstCameraFacing(Facing.FRONT);
	CameraId backCameraId = mOneCameraManager.findFirstCameraFacing(Facing.BACK);

	// The exposure compensation is supported when both of the following conditions meet
	// - we have the valid camera, and
	// - the valid camera supports the exposure compensation
	boolean isExposureCompensationSupportedByFrontCamera = (frontCameraId != null) &&
	(mOneCameraManager.getOneCameraCharacteristics(frontCameraId)
	.isExposureCompensationSupported());
	boolean isExposureCompensationSupportedByBackCamera = (backCameraId != null) &&
	(mOneCameraManager.getOneCameraCharacteristics(backCameraId)
	.isExposureCompensationSupported());

	// Hides the option if neither front and back camera support exposure compensation.
	if (!isExposureCompensationSupportedByFrontCamera &&
	!isExposureCompensationSupportedByBackCamera) {
	hideAdvancedScreen = true;
	}
	} catch (OneCameraAccessException e) {
	fatalErrorHandler.onGenericCameraAccessFailure();
	}

	ActionBar actionBar = getActionBar();
	actionBar.setDisplayHomeAsUpEnabled(true);
	actionBar.setTitle(R.string.mode_settings);

	String prefKey = getIntent().getStringExtra(PREF_SCREEN_EXTRA);
	CameraSettingsFragment dialog = new CameraSettingsFragment();
	Bundle bundle = new Bundle(1);
	bundle.putString(PREF_SCREEN_EXTRA, prefKey);
	bundle.putBoolean(HIDE_ADVANCED_SCREEN, hideAdvancedScreen);
	dialog.setArguments(bundle);
	getFragmentManager().beginTransaction().replace(android.R.id.content, dialog).commit();
	}

	@Override
	public boolean onMenuItemSelected(int featureId, MenuItem item) {
	int itemId = item.getItemId();
	if (itemId == android.R.id.home) {
	finish();
	return true;
	}
	return true;
	}

	public static class CameraSettingsFragment extends PreferenceFragment implements
	OnSharedPreferenceChangeListener {

	public static final String PREF_CATEGORY_RESOLUTION = "pref_category_resolution";
	public static final String PREF_CATEGORY_ADVANCED = "pref_category_advanced";
	public static final String PREF_LAUNCH_HELP = "pref_launch_help";
	private static final Log.Tag TAG = new Log.Tag("SettingsFragment");
	private static DecimalFormat sMegaPixelFormat = new DecimalFormat("##0.0");
	private String[] mCamcorderProfileNames;
	private CameraDeviceInfo mInfos;
	private String mPrefKey;
	private boolean mHideAdvancedScreen;
	private boolean mGetSubPrefAsRoot = true;

	// Selected resolutions for the different cameras and sizes.
	private PictureSizes mPictureSizes;

	@Override
	public void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	Bundle arguments = getArguments();
	if (arguments != null) {
	mPrefKey = arguments.getString(PREF_SCREEN_EXTRA);
	mHideAdvancedScreen = arguments.getBoolean(HIDE_ADVANCED_SCREEN);
	}
	Context context = this.getActivity().getApplicationContext();
	addPreferencesFromResource(R.xml.camera_preferences);
	PreferenceScreen advancedScreen =
	(PreferenceScreen) findPreference(PREF_CATEGORY_ADVANCED);

	// If manual exposure not enabled, hide the Advanced screen.
	if (mHideAdvancedScreen) {
	PreferenceScreen root = (PreferenceScreen) findPreference("prefscreen_top");
	root.removePreference(advancedScreen);
	}

	// Allow the Helper to edit the full preference hierarchy, not the
	// sub tree we may show as root. See {@link #getPreferenceScreen()}.
	mGetSubPrefAsRoot = false;
	CameraSettingsActivityHelper.addAdditionalPreferences(this, context);
	mGetSubPrefAsRoot = true;

	mCamcorderProfileNames = getResources().getStringArray(R.array.camcorder_profile_names);
	mInfos = CameraAgentFactory
	.getAndroidCameraAgent(context, CameraAgentFactory.CameraApi.API_1)
	.getCameraDeviceInfo();
	CameraAgentFactory.recycle(CameraAgentFactory.CameraApi.API_1);
	}

	@Override
	public void onResume() {
	super.onResume();
	final Activity activity = this.getActivity();

	// Load the camera sizes.
	loadSizes();

	// Send loaded sizes to additional preferences.
	CameraSettingsActivityHelper.onSizesLoaded(this, mPictureSizes.backCameraSizes,
	new ListPreferenceFiller() {
	@Override
	public void fill(List<Size> sizes, ListPreference preference) {
	setEntriesForSelection(sizes, preference);
	}
	});

	// Make sure to hide settings for cameras that don't exist on this
	// device.
	setVisibilities();

	// Put in the summaries for the currently set values.
	final PreferenceScreen resolutionScreen =
	(PreferenceScreen) findPreference(PREF_CATEGORY_RESOLUTION);
	fillEntriesAndSummaries(resolutionScreen);
	setPreferenceScreenIntent(resolutionScreen);

	final PreferenceScreen advancedScreen =
	(PreferenceScreen) findPreference(PREF_CATEGORY_ADVANCED);

	if (!mHideAdvancedScreen) {
	setPreferenceScreenIntent(advancedScreen);
	}

	Preference helpPref = findPreference(PREF_LAUNCH_HELP);
	helpPref.setOnPreferenceClickListener(
	new OnPreferenceClickListener() {
	@Override
	public boolean onPreferenceClick(Preference preference) {
	new GoogleHelpHelper(activity).launchGoogleHelp();
	return true;
	}
	});
	getPreferenceScreen().getSharedPreferences()
	.registerOnSharedPreferenceChangeListener(this);
	}

	/**
	* Configure home-as-up for sub-screens.
	*/
	private void setPreferenceScreenIntent(final PreferenceScreen preferenceScreen) {
	Intent intent = new Intent(getActivity(), CameraSettingsActivity.class);
	intent.putExtra(PREF_SCREEN_EXTRA, preferenceScreen.getKey());
	preferenceScreen.setIntent(intent);
	}

	/**
	* This override allows the CameraSettingsFragment to be reused for
	* different nested PreferenceScreens within the single camera
	* preferences XML resource. If the fragment is constructed with a
	* desired preference key (delivered via an extra in the creation
	* intent), it is used to look up the nested PreferenceScreen and
	* returned here.
	*/
	@Override
	public PreferenceScreen getPreferenceScreen() {
	PreferenceScreen root = super.getPreferenceScreen();
	if (!mGetSubPrefAsRoot \|\| mPrefKey == null \|\| root == null) {
	return root;
	} else {
	PreferenceScreen match = findByKey(root, mPrefKey);
	if (match != null) {
	return match;
	} else {
	throw new RuntimeException("key " + mPrefKey + " not found");
	}
	}
	}

	private PreferenceScreen findByKey(PreferenceScreen parent, String key) {
	if (key.equals(parent.getKey())) {
	return parent;
	} else {
	for (int i = 0; i < parent.getPreferenceCount(); i++) {
	Preference child = parent.getPreference(i);
	if (child instanceof PreferenceScreen) {
	PreferenceScreen match = findByKey((PreferenceScreen) child, key);
	if (match != null) {
	return match;
	}
	}
	}
	return null;
	}
	}

	/**
	* Depending on camera availability on the device, this removes settings
	* for cameras the device doesn't have.
	*/
	private void setVisibilities() {
	PreferenceGroup resolutions =
	(PreferenceGroup) findPreference(PREF_CATEGORY_RESOLUTION);
	if (mPictureSizes.backCameraSizes.isEmpty()) {
	recursiveDelete(resolutions,
	findPreference(Keys.KEY_PICTURE_SIZE_BACK));
	recursiveDelete(resolutions,
	findPreference(Keys.KEY_VIDEO_QUALITY_BACK));
	}
	if (mPictureSizes.frontCameraSizes.isEmpty()) {
	recursiveDelete(resolutions,
	findPreference(Keys.KEY_PICTURE_SIZE_FRONT));
	recursiveDelete(resolutions,
	findPreference(Keys.KEY_VIDEO_QUALITY_FRONT));
	}
	}

	/**
	* Recursively go through settings and fill entries and summaries of our
	* preferences.
	*/
	private void fillEntriesAndSummaries(PreferenceGroup group) {
	for (int i = 0; i < group.getPreferenceCount(); ++i) {
	Preference pref = group.getPreference(i);
	if (pref instanceof PreferenceGroup) {
	fillEntriesAndSummaries((PreferenceGroup) pref);
	}
	setSummary(pref);
	setEntries(pref);
	}
	}

	/**
	* Recursively traverses the tree from the given group as the route and
	* tries to delete the preference. Traversal stops once the preference
	* was found and removed.
	*/
	private boolean recursiveDelete(PreferenceGroup group, Preference preference) {
	if (group == null) {
	Log.d(TAG, "attempting to delete from null preference group");
	return false;
	}
	if (preference == null) {
	Log.d(TAG, "attempting to delete null preference");
	return false;
	}
	if (group.removePreference(preference)) {
	// Removal was successful.
	return true;
	}

	for (int i = 0; i < group.getPreferenceCount(); ++i) {
	Preference pref = group.getPreference(i);
	if (pref instanceof PreferenceGroup) {
	if (recursiveDelete((PreferenceGroup) pref, preference)) {
	return true;
	}
	}
	}
	return false;
	}

	@Override
	public void onPause() {
	super.onPause();
	getPreferenceScreen().getSharedPreferences()
	.unregisterOnSharedPreferenceChangeListener(this);
	}

	@Override
	public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
	setSummary(findPreference(key));
	}

	/**
	* Set the entries for the given preference. The given preference needs
	* to be a {@link ListPreference}
	*/
	private void setEntries(Preference preference) {
	if (!(preference instanceof ListPreference)) {
	return;
	}

	ListPreference listPreference = (ListPreference) preference;
	if (listPreference.getKey().equals(Keys.KEY_PICTURE_SIZE_BACK)) {
	setEntriesForSelection(mPictureSizes.backCameraSizes, listPreference);
	} else if (listPreference.getKey().equals(Keys.KEY_PICTURE_SIZE_FRONT)) {
	setEntriesForSelection(mPictureSizes.frontCameraSizes, listPreference);
	} else if (listPreference.getKey().equals(Keys.KEY_VIDEO_QUALITY_BACK)) {
	setEntriesForSelection(mPictureSizes.videoQualitiesBack.orNull(), listPreference);
	} else if (listPreference.getKey().equals(Keys.KEY_VIDEO_QUALITY_FRONT)) {
	setEntriesForSelection(mPictureSizes.videoQualitiesFront.orNull(), listPreference);
	}
	}

	/**
	* Set the summary for the given preference. The given preference needs
	* to be a {@link ListPreference}.
	*/
	private void setSummary(Preference preference) {
	if (!(preference instanceof ListPreference)) {
	return;
	}

	ListPreference listPreference = (ListPreference) preference;
	if (listPreference.getKey().equals(Keys.KEY_PICTURE_SIZE_BACK)) {
	setSummaryForSelection(mPictureSizes.backCameraSizes,
	listPreference);
	} else if (listPreference.getKey().equals(Keys.KEY_PICTURE_SIZE_FRONT)) {
	setSummaryForSelection(mPictureSizes.frontCameraSizes,
	listPreference);
	} else if (listPreference.getKey().equals(Keys.KEY_VIDEO_QUALITY_BACK)) {
	setSummaryForSelection(mPictureSizes.videoQualitiesBack.orNull(), listPreference);
	} else if (listPreference.getKey().equals(Keys.KEY_VIDEO_QUALITY_FRONT)) {
	setSummaryForSelection(mPictureSizes.videoQualitiesFront.orNull(), listPreference);
	} else {
	listPreference.setSummary(listPreference.getEntry());
	}
	}

	/**
	* Sets the entries for the given list preference.
	*
	* @param selectedSizes The possible S,M,L entries the user can choose
	* from.
	* @param preference The preference to set the entries for.
	*/
	private void setEntriesForSelection(List<Size> selectedSizes,
	ListPreference preference) {
	if (selectedSizes == null) {
	return;
	}

	String[] entries = new String[selectedSizes.size()];
	String[] entryValues = new String[selectedSizes.size()];
	for (int i = 0; i < selectedSizes.size(); i++) {
	Size size = selectedSizes.get(i);
	entries[i] = getSizeSummaryString(size);
	entryValues[i] = SettingsUtil.sizeToSettingString(size);
	}
	preference.setEntries(entries);
	preference.setEntryValues(entryValues);
	}

	/**
	* Sets the entries for the given list preference.
	*
	* @param selectedQualities The possible S,M,L entries the user can
	* choose from.
	* @param preference The preference to set the entries for.
	*/
	private void setEntriesForSelection(SelectedVideoQualities selectedQualities,
	ListPreference preference) {
	if (selectedQualities == null) {
	return;
	}

	// Avoid adding double entries at the bottom of the list which
	// indicates that not at least 3 qualities are supported.
	ArrayList<String> entries = new ArrayList<String>();
	entries.add(mCamcorderProfileNames[selectedQualities.large]);
	if (selectedQualities.medium != selectedQualities.large) {
	entries.add(mCamcorderProfileNames[selectedQualities.medium]);
	}
	if (selectedQualities.small != selectedQualities.medium) {
	entries.add(mCamcorderProfileNames[selectedQualities.small]);
	}
	preference.setEntries(entries.toArray(new String[0]));
	}

	/**
	* Sets the summary for the given list preference.
	*
	* @param displayableSizes The human readable preferred sizes
	* @param preference The preference for which to set the summary.
	*/
	private void setSummaryForSelection(List<Size> displayableSizes,
	ListPreference preference) {
	String setting = preference.getValue();
	if (setting == null \|\| !setting.contains("x")) {
	return;
	}
	Size settingSize = SettingsUtil.sizeFromSettingString(setting);
	if (settingSize == null \|\| settingSize.area() == 0) {
	return;
	}
	preference.setSummary(getSizeSummaryString(settingSize));
	}

	/**
	* Sets the summary for the given list preference.
	*
	* @param selectedQualities The selected video qualities.
	* @param preference The preference for which to set the summary.
	*/
	private void setSummaryForSelection(SelectedVideoQualities selectedQualities,
	ListPreference preference) {
	if (selectedQualities == null) {
	return;
	}

	int selectedQuality = selectedQualities.getFromSetting(preference.getValue());
	preference.setSummary(mCamcorderProfileNames[selectedQuality]);
	}

	/**
	* This method gets the selected picture sizes for S,M,L and populates
	* {@link #mPictureSizes} accordingly.
	*/
	private void loadSizes() {
	if (mInfos == null) {
	Log.w(TAG, "null deviceInfo, cannot display resolution sizes");
	return;
	}
	PictureSizeLoader loader = new PictureSizeLoader(getActivity().getApplicationContext());
	mPictureSizes = loader.computePictureSizes();
	loader.release();
	}

	/**
	* @param size The photo resolution.
	* @return A human readable and translated string for labeling the
	* picture size in megapixels.
	*/
	private String getSizeSummaryString(Size size) {
	Size approximateSize = ResolutionUtil.getApproximateSize(size);
	String megaPixels = sMegaPixelFormat.format((size.width() * size.height()) / 1e6);
	int numerator = ResolutionUtil.aspectRatioNumerator(approximateSize);
	int denominator = ResolutionUtil.aspectRatioDenominator(approximateSize);
	String result = getResources().getString(
	R.string.setting_summary_aspect_ratio_and_megapixels, numerator, denominator,
	megaPixels);
	return result;
	}
	}
	}