Add camera parameter key constants and documentation.

    void dump() const;

    status_t dump(int fd, const Vector<String16>& args) const;

    // Parameter keys to communicate between camera application and driver.

    // The access (read/write, read only, or write only) is viewed from the

    // perspective of applications, not driver.

    // Preview frame size in pixels (width x height).

    // Example value: "480x320". Read/Write.

    static const char KEY_PREVIEW_SIZE[];

    // Supported preview frame sizes in pixels.

    // Example value: "800x600,480x320". Read only.

    static const char KEY_SUPPORTED_PREVIEW_SIZES[];

    // The image format for preview frames.

    // Example value: "yuv420sp" or PIXEL_FORMAT_XXX constants. Read/write.

    static const char KEY_PREVIEW_FORMAT[];

    // Supported image formats for preview frames.

    // Example value: "yuv420sp,yuv422i-yuyv". Read only.

    static const char KEY_SUPPORTED_PREVIEW_FORMATS[];

    // Number of preview frames per second.

    // Example value: "15". Read/write.

    static const char KEY_PREVIEW_FRAME_RATE[];

    // Supported number of preview frames per second.

    // Example value: "24,15,10". Read.

    static const char KEY_SUPPORTED_PREVIEW_FRAME_RATES[];

    // The dimensions for captured pictures in pixels (width x height).

    // Example value: "1024x768". Read/write.

    static const char KEY_PICTURE_SIZE[];

    // Supported dimensions for captured pictures in pixels.

    // Example value: "2048x1536,1024x768". Read only.

    static const char KEY_SUPPORTED_PICTURE_SIZES[];

    // The image format for captured pictures.

    // Example value: "jpeg" or PIXEL_FORMAT_XXX constants. Read/write.

    static const char KEY_PICTURE_FORMAT[];

    // Supported image formats for captured pictures.

    // Example value: "jpeg,rgb565". Read only.

    static const char KEY_SUPPORTED_PICTURE_FORMATS[];

    // The width (in pixels) of EXIF thumbnail in Jpeg picture.

    // Example value: "512". Read/write.

    static const char KEY_JPEG_THUMBNAIL_WIDTH[];

    // The height (in pixels) of EXIF thumbnail in Jpeg picture.

    // Example value: "384". Read/write.

    static const char KEY_JPEG_THUMBNAIL_HEIGHT[];

    // Supported EXIF thumbnail sizes (width x height).

    // Example value: "512x384,320x240". Read only.

    static const char KEY_SUPPORTED_THUMBNAIL_SIZES[];

    // The quality of the EXIF thumbnail in Jpeg picture. The range is 1 to 100,

    // with 100 being the best.

    // Example value: "90". Read/write.

    static const char KEY_JPEG_THUMBNAIL_QUALITY[];

    // Jpeg quality of captured picture. The range is 1 to 100, with 100 being

    // the best.

    // Example value: "90". Read/write.

    static const char KEY_JPEG_QUALITY[];

    // The orientation of the device in degrees. For example, suppose the

    // natural position of the device is landscape. If the user takes a picture

    // in landscape mode in 2048x1536 resolution, the rotation will be set to

    // "0". If the user rotates the phone 90 degrees clockwise, the rotation

    // should be set to "90".

    // The camera driver can set orientation in the EXIF header without rotating

    // the picture. Or the driver can rotate the picture and the EXIF thumbnail.

    // If the Jpeg picture is rotated, the orientation in the EXIF header should

    // be missing or 1 (row #0 is top and column #0 is left side). The driver

    // should not set default value for this parameter.

    // Example value: "0" or "90" or "180" or "270". Write only.

    static const char KEY_ROTATION[];

    // GPS latitude coordinate. This will be stored in JPEG EXIF header.

    // Example value: "25.032146". Write only.

    static const char KEY_GPS_LATITUDE[];

    // GPS longitude coordinate. This will be stored in JPEG EXIF header.

    // Example value: "121.564448". Write only.

    static const char KEY_GPS_LONGITUDE[];

    // GPS altitude. This will be stored in JPEG EXIF header.

    // Example value: "21.0". Write only.

    static const char KEY_GPS_ALTITUDE[];

    // GPS timestamp (UTC in seconds since January 1, 1970). This should be

    // stored in JPEG EXIF header.

    // Example value: "1251192757". Write only.

    static const char KEY_GPS_TIMESTAMP[];

    // Current white balance setting.

    // Example value: "auto" or WHITE_BALANCE_XXX constants. Read/write.

    static const char KEY_WHITE_BALANCE[];

    // Supported white balance settings.

    // Example value: "auto,incandescent,daylight". Read only.

    static const char KEY_SUPPORTED_WHITE_BALANCE[];

    // Current color effect setting.

    // Example value: "none" or EFFECT_XXX constants. Read/write.

    static const char KEY_EFFECT[];

    // Supported color effect settings.

    // Example value: "none,mono,sepia". Read only.

    static const char KEY_SUPPORTED_EFFECTS[];

    // Current antibanding setting.

    // Example value: "auto" or ANTIBANDING_XXX constants. Read/write.

    static const char KEY_ANTIBANDING[];

    // Supported antibanding settings.

    // Example value: "auto,50hz,60hz,off". Read only.

    static const char KEY_SUPPORTED_ANTIBANDING[];

    // Current scene mode.

    // Example value: "auto" or SCENE_MODE_XXX constants. Read/write.

    static const char KEY_SCENE_MODE[];

    // Supported scene mode settings.

    // Example value: "auto,night,fireworks". Read only.

    static const char KEY_SUPPORTED_SCENE_MODES[];

    // Current flash mode.

    // Example value: "auto" or FLASH_MODE_XXX constants. Read/write.

    static const char KEY_FLASH_MODE[];

    // Supported flash modes.

    // Example value: "auto,on,off". Read only.

    static const char KEY_SUPPORTED_FLASH_MODES[];

    // Current focus mode. If the camera does not support auto-focus, the value

    // should be FOCUS_MODE_FIXED. If the focus mode is not FOCUS_MODE_FIXED or

    // or FOCUS_MODE_INFINITY, applications should call

    // CameraHardwareInterface.autoFocus to start the focus.

    // Example value: "auto" or FOCUS_MODE_XXX constants. Read/write.

    static const char KEY_FOCUS_MODE[];

    // Supported focus modes.

    // Example value: "auto,macro,fixed". Read only.

    static const char KEY_SUPPORTED_FOCUS_MODES[];

        // Values for white balance settings.

    static const char WHITE_BALANCE_AUTO[];

    static const char WHITE_BALANCE_INCANDESCENT[];

    static const char WHITE_BALANCE_FLUORESCENT[];

    static const char WHITE_BALANCE_WARM_FLUORESCENT[];

    static const char WHITE_BALANCE_DAYLIGHT[];

    static const char WHITE_BALANCE_CLOUDY_DAYLIGHT[];

    static const char WHITE_BALANCE_TWILIGHT[];

    static const char WHITE_BALANCE_SHADE[];

    // Values for effect settings.

    static const char EFFECT_NONE[];

    static const char EFFECT_MONO[];

    static const char EFFECT_NEGATIVE[];

    static const char EFFECT_SOLARIZE[];

    static const char EFFECT_SEPIA[];

    static const char EFFECT_POSTERIZE[];

    static const char EFFECT_WHITEBOARD[];

    static const char EFFECT_BLACKBOARD[];

    static const char EFFECT_AQUA[];

    // Values for antibanding settings.

    static const char ANTIBANDING_AUTO[];

    static const char ANTIBANDING_50HZ[];

    static const char ANTIBANDING_60HZ[];

    static const char ANTIBANDING_OFF[];

    // Values for flash mode settings.

    // Flash will not be fired.

    static const char FLASH_MODE_OFF[];

    // Flash will be fired automatically when required. The timing is decided by

    // camera driver.

    static const char FLASH_MODE_AUTO[];

    // Flash will always be fired. The timing is decided by camera driver.

    static const char FLASH_MODE_ON[];

    // Flash will be fired in red-eye reduction mode.

    static const char FLASH_MODE_RED_EYE[];

    // Constant emission of light. This can be used for video recording.

    static const char FLASH_MODE_VIDEO_LIGHT[];

    // Values for scene mode settings.

    static const char SCENE_MODE_AUTO[];

    static const char SCENE_MODE_ACTION[];

    static const char SCENE_MODE_PORTRAIT[];

    static const char SCENE_MODE_LANDSCAPE[];

    static const char SCENE_MODE_NIGHT[];

    static const char SCENE_MODE_NIGHT_PORTRAIT[];

    static const char SCENE_MODE_THEATRE[];

    static const char SCENE_MODE_BEACH[];

    static const char SCENE_MODE_SNOW[];

    static const char SCENE_MODE_SUNSET[];

    static const char SCENE_MODE_STEADYPHOTO[];

    static const char SCENE_MODE_FIREWORKS[];

    static const char SCENE_MODE_SPORTS[];

    static const char SCENE_MODE_PARTY[];

    static const char SCENE_MODE_CANDLELIGHT[];

    // Formats for setPreviewFormat and setPictureFormat.

    static const char PIXEL_FORMAT_YUV422SP[];

    static const char PIXEL_FORMAT_YUV420SP[]; // NV21

    static const char PIXEL_FORMAT_YUV422I[]; // YUY2

    static const char PIXEL_FORMAT_RGB565[];

    static const char PIXEL_FORMAT_JPEG[];

    // Values for focus mode settings.

    // Auto-focus mode.

    static const char FOCUS_MODE_AUTO[];

    // Focus is set at infinity. Applications should not call

    // CameraHardwareInterface.autoFocus in this mode.

    static const char FOCUS_MODE_INFINITY[];

    static const char FOCUS_MODE_MACRO[];

    // Focus is fixed. The camera is always in this mode if the focus is not

    // adjustable. If the camera has auto-focus, this mode can fix the

    // focus, which is usually at hyperfocal distance. Applications should

    // not call CameraHardwareInterface.autoFocus in this mode.

    static const char FOCUS_MODE_FIXED[];

private:

    DefaultKeyedVector<String8,String8>    mMap;

};

}; // namespace android

#endif

#include <ui/CameraParameters.h>

namespace android {

// Parameter keys to communicate between camera application and driver.

const char CameraParameters::KEY_PREVIEW_SIZE[] = "preview-size";

const char CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES[] = "preview-size-values";

const char CameraParameters::KEY_PREVIEW_FORMAT[] = "preview-format";

const char CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS[] = "preview-format-values";

const char CameraParameters::KEY_PREVIEW_FRAME_RATE[] = "preview-frame-rate";

const char CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES[] = "preview-frame-rate-values";

const char CameraParameters::KEY_PICTURE_SIZE[] = "picture-size";

const char CameraParameters::KEY_SUPPORTED_PICTURE_SIZES[] = "picture-size-values";

const char CameraParameters::KEY_PICTURE_FORMAT[] = "picture-format";

const char CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS[] = "picture-format-values";

const char CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH[] = "jpeg-thumbnail-width";

const char CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT[] = "jpeg-thumbnail-height";

const char CameraParameters::KEY_SUPPORTED_THUMBNAIL_SIZES[] = "jpeg-thumbnail-size-values";

const char CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY[] = "jpeg-thumbnail-quality";

const char CameraParameters::KEY_JPEG_QUALITY[] = "jpeg-quality";

const char CameraParameters::KEY_ROTATION[] = "rotation";

const char CameraParameters::KEY_GPS_LATITUDE[] = "gps-latitude";

const char CameraParameters::KEY_GPS_LONGITUDE[] = "gps-longitude";

const char CameraParameters::KEY_GPS_ALTITUDE[] = "gps-altitude";

const char CameraParameters::KEY_GPS_TIMESTAMP[] = "gps-timestamp";

const char CameraParameters::KEY_WHITE_BALANCE[] = "whitebalance";

const char CameraParameters::KEY_SUPPORTED_WHITE_BALANCE[] = "whitebalance-values";

const char CameraParameters::KEY_EFFECT[] = "effect";

const char CameraParameters::KEY_SUPPORTED_EFFECTS[] = "effect-values";

const char CameraParameters::KEY_ANTIBANDING[] = "antibanding";

const char CameraParameters::KEY_SUPPORTED_ANTIBANDING[] = "antibanding-values";

const char CameraParameters::KEY_SCENE_MODE[] = "scene-mode";

const char CameraParameters::KEY_SUPPORTED_SCENE_MODES[] = "scene-mode-values";

const char CameraParameters::KEY_FLASH_MODE[] = "flash-mode";

const char CameraParameters::KEY_SUPPORTED_FLASH_MODES[] = "flash-mode-values";

const char CameraParameters::KEY_FOCUS_MODE[] = "focus-mode";

const char CameraParameters::KEY_SUPPORTED_FOCUS_MODES[] = "focus-mode-values";

// Values for white balance settings.

const char CameraParameters::WHITE_BALANCE_AUTO[] = "auto";

const char CameraParameters::WHITE_BALANCE_INCANDESCENT[] = "incandescent";

const char CameraParameters::WHITE_BALANCE_FLUORESCENT[] = "fluorescent";

const char CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT[] = "warm-fluorescent";

const char CameraParameters::WHITE_BALANCE_DAYLIGHT[] = "daylight";

const char CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT[] = "cloudy-daylight";

const char CameraParameters::WHITE_BALANCE_TWILIGHT[] = "twilight";

const char CameraParameters::WHITE_BALANCE_SHADE[] = "shade";

// Values for effect settings.

const char CameraParameters::EFFECT_NONE[] = "none";

const char CameraParameters::EFFECT_MONO[] = "mono";

const char CameraParameters::EFFECT_NEGATIVE[] = "negative";

const char CameraParameters::EFFECT_SOLARIZE[] = "solarize";

const char CameraParameters::EFFECT_SEPIA[] = "sepia";

const char CameraParameters::EFFECT_POSTERIZE[] = "posterize";

const char CameraParameters::EFFECT_WHITEBOARD[] = "whiteboard";

const char CameraParameters::EFFECT_BLACKBOARD[] = "blackboard";

const char CameraParameters::EFFECT_AQUA[] = "aqua";

// Values for antibanding settings.

const char CameraParameters::ANTIBANDING_AUTO[] = "auto";

const char CameraParameters::ANTIBANDING_50HZ[] = "50hz";

const char CameraParameters::ANTIBANDING_60HZ[] = "60hz";

const char CameraParameters::ANTIBANDING_OFF[] = "off";

// Values for flash mode settings.

const char CameraParameters::FLASH_MODE_OFF[] = "off";

const char CameraParameters::FLASH_MODE_AUTO[] = "auto";

const char CameraParameters::FLASH_MODE_ON[] = "on";

const char CameraParameters::FLASH_MODE_RED_EYE[] = "red-eye";

const char CameraParameters::FLASH_MODE_VIDEO_LIGHT[] = "video-light";

// Values for scene mode settings.

const char CameraParameters::SCENE_MODE_AUTO[] = "auto";

const char CameraParameters::SCENE_MODE_ACTION[] = "action";

const char CameraParameters::SCENE_MODE_PORTRAIT[] = "portrait";

const char CameraParameters::SCENE_MODE_LANDSCAPE[] = "landscape";

const char CameraParameters::SCENE_MODE_NIGHT[] = "night";

const char CameraParameters::SCENE_MODE_NIGHT_PORTRAIT[] = "night-portrait";

const char CameraParameters::SCENE_MODE_THEATRE[] = "theatre";

const char CameraParameters::SCENE_MODE_BEACH[] = "beach";

const char CameraParameters::SCENE_MODE_SNOW[] = "snow";

const char CameraParameters::SCENE_MODE_SUNSET[] = "sunset";

const char CameraParameters::SCENE_MODE_STEADYPHOTO[] = "steadyphoto";

const char CameraParameters::SCENE_MODE_FIREWORKS[] = "fireworks";

const char CameraParameters::SCENE_MODE_SPORTS[] = "sports";

const char CameraParameters::SCENE_MODE_PARTY[] = "party";

const char CameraParameters::SCENE_MODE_CANDLELIGHT[] = "candlelight";

// Formats for setPreviewFormat and setPictureFormat.

const char CameraParameters::PIXEL_FORMAT_YUV422SP[] = "yuv422sp";

const char CameraParameters::PIXEL_FORMAT_YUV420SP[] = "yuv420sp";

const char CameraParameters::PIXEL_FORMAT_YUV422I[] = "yuv422i-yuyv";

const char CameraParameters::PIXEL_FORMAT_RGB565[] = "rgb565";

const char CameraParameters::PIXEL_FORMAT_JPEG[] = "jpeg";

// Values for focus mode settings.

const char CameraParameters::FOCUS_MODE_AUTO[] = "auto";

const char CameraParameters::FOCUS_MODE_INFINITY[] = "infinity";

const char CameraParameters::FOCUS_MODE_MACRO[] = "macro";

const char CameraParameters::FOCUS_MODE_FIXED[] = "fixed";

static const char* portrait = "portrait";

static const char* landscape = "landscape";

{

    char str[32];

    sprintf(str, "%dx%d", width, height);

    set("preview-size", str);

    set(KEY_PREVIEW_SIZE, str);

}

void CameraParameters::getPreviewSize(int *width, int *height) const

    *height = -1;

    // Get the current string, if it doesn't exist, leave the -1x-1

    const char *p = get("preview-size");

    const char *p = get(KEY_PREVIEW_SIZE);

    if (p == 0)

        return;

void CameraParameters::setPreviewFrameRate(int fps)

{

    set("preview-frame-rate", fps);

    set(KEY_PREVIEW_FRAME_RATE, fps);

}

int CameraParameters::getPreviewFrameRate() const

{

    return getInt("preview-frame-rate");

    return getInt(KEY_PREVIEW_FRAME_RATE);

}

void CameraParameters::setPreviewFormat(const char *format)

{

    set("preview-format", format);

    set(KEY_PREVIEW_FORMAT, format);

}

int CameraParameters::getOrientation() const

void CameraParameters::setOrientation(int orientation)

{

    if (orientation == CAMERA_ORIENTATION_PORTRAIT) {

        set("preview-format", portrait);

        set("orientation", portrait);

    } else {

        set("preview-format", landscape);

        set("orientation", landscape);

    }

}

const char *CameraParameters::getPreviewFormat() const

{

    return get("preview-format");

    return get(KEY_PREVIEW_FORMAT);

}

void CameraParameters::setPictureSize(int width, int height)

{

    char str[32];

    sprintf(str, "%dx%d", width, height);

    set("picture-size", str);

    set(KEY_PICTURE_SIZE, str);

}

void CameraParameters::getPictureSize(int *width, int *height) const

    *height = -1;

    // Get the current string, if it doesn't exist, leave the -1x-1

    const char *p = get("picture-size");

    const char *p = get(KEY_PICTURE_SIZE);

    if (p == 0)

        return;

void CameraParameters::setPictureFormat(const char *format)

{

    set("picture-format", format);

    set(KEY_PICTURE_FORMAT, format);

}

const char *CameraParameters::getPictureFormat() const

{

    return get("picture-format");

    return get(KEY_PICTURE_FORMAT);

}

void CameraParameters::dump() const