Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

am c1e7b218: Merge "Improve input device calibration format." into gingerbread

Browse Source 
Merge commit 'c1e7b2182594aa0463c4a738cc8e7eea6777ef50' into gingerbread-plus-aosp

* commit 'c1e7b2182594aa0463c4a738cc8e7eea6777ef50':
  Improve input device calibration format.
This commit is contained in:
Jeff Brown
2010-10-15 01:31:14 -07:00
committed by Android Git Automerger
parent dc3ad87c04 c1e7b21825
commit 5f0cbfcecc
2 changed files with 201 additions and 129 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
include/ui/InputReader.h
View File

@@ -571,31 +571,36 @@ protected:
// Immutable calibration parameters in parsed form. // Immutable calibration parameters in parsed form.
struct Calibration { struct Calibration {
// Touch Area // Touch Size
enum TouchAreaCalibration { enum TouchSizeCalibration {
TOUCH_AREA_CALIBRATION_DEFAULT, TOUCH_SIZE_CALIBRATION_DEFAULT,
TOUCH_AREA_CALIBRATION_NONE, TOUCH_SIZE_CALIBRATION_NONE,
TOUCH_AREA_CALIBRATION_GEOMETRIC, TOUCH_SIZE_CALIBRATION_GEOMETRIC,
TOUCH_AREA_CALIBRATION_PRESSURE, TOUCH_SIZE_CALIBRATION_PRESSURE,
}; };
TouchAreaCalibration touchAreaCalibration; TouchSizeCalibration touchSizeCalibration;
// Tool Area // Tool Size
enum ToolAreaCalibration { enum ToolSizeCalibration {
TOOL_AREA_CALIBRATION_DEFAULT, TOOL_SIZE_CALIBRATION_DEFAULT,
TOOL_AREA_CALIBRATION_NONE, TOOL_SIZE_CALIBRATION_NONE,
TOOL_AREA_CALIBRATION_GEOMETRIC, TOOL_SIZE_CALIBRATION_GEOMETRIC,
TOOL_AREA_CALIBRATION_LINEAR, TOOL_SIZE_CALIBRATION_LINEAR,
TOOL_SIZE_CALIBRATION_AREA,
}; };
ToolAreaCalibration toolAreaCalibration; ToolSizeCalibration toolSizeCalibration;
bool haveToolAreaLinearScale; bool haveToolSizeLinearScale;
float toolAreaLinearScale; float toolSizeLinearScale;
bool haveToolAreaLinearBias; bool haveToolSizeLinearBias;
float toolAreaLinearBias; float toolSizeLinearBias;
bool haveToolAreaIsSummed; bool haveToolSizeAreaScale;
int32_t toolAreaIsSummed; float toolSizeAreaScale;
bool haveToolSizeAreaBias;
float toolSizeAreaBias;
bool haveToolSizeIsSummed;
int32_t toolSizeIsSummed;
// Pressure // Pressure
enum PressureCalibration { enum PressureCalibration {
@@ -671,8 +676,10 @@ protected:
float geometricScale; float geometricScale;
float toolAreaLinearScale; float toolSizeLinearScale;
float toolAreaLinearBias; float toolSizeLinearBias;
float toolSizeAreaScale;
float toolSizeAreaBias;
float pressureScale; float pressureScale;
@@ -691,11 +698,11 @@ protected:
bool haveSize; bool haveSize;
InputDeviceInfo::MotionRange size; InputDeviceInfo::MotionRange size;
bool haveTouchArea; bool haveTouchSize;
InputDeviceInfo::MotionRange touchMajor; InputDeviceInfo::MotionRange touchMajor;
InputDeviceInfo::MotionRange touchMinor; InputDeviceInfo::MotionRange touchMinor;
bool haveToolArea; bool haveToolSize;
InputDeviceInfo::MotionRange toolMajor; InputDeviceInfo::MotionRange toolMajor;
InputDeviceInfo::MotionRange toolMinor; InputDeviceInfo::MotionRange toolMinor;

275
libs/ui/InputReader.cpp
View File

@@ -1246,14 +1246,14 @@ void TouchInputMapper::populateDeviceInfo(InputDeviceInfo* info) {
mLocked.orientedRanges.size); mLocked.orientedRanges.size);
} }
if (mLocked.orientedRanges.haveTouchArea) { if (mLocked.orientedRanges.haveTouchSize) {
info->addMotionRange(AINPUT_MOTION_RANGE_TOUCH_MAJOR, info->addMotionRange(AINPUT_MOTION_RANGE_TOUCH_MAJOR,
mLocked.orientedRanges.touchMajor); mLocked.orientedRanges.touchMajor);
info->addMotionRange(AINPUT_MOTION_RANGE_TOUCH_MINOR, info->addMotionRange(AINPUT_MOTION_RANGE_TOUCH_MINOR,
mLocked.orientedRanges.touchMinor); mLocked.orientedRanges.touchMinor);
} }
if (mLocked.orientedRanges.haveToolArea) { if (mLocked.orientedRanges.haveToolSize) {
info->addMotionRange(AINPUT_MOTION_RANGE_TOOL_MAJOR, info->addMotionRange(AINPUT_MOTION_RANGE_TOOL_MAJOR,
mLocked.orientedRanges.toolMajor); mLocked.orientedRanges.toolMajor);
info->addMotionRange(AINPUT_MOTION_RANGE_TOOL_MINOR, info->addMotionRange(AINPUT_MOTION_RANGE_TOOL_MINOR,
@@ -1277,8 +1277,21 @@ void TouchInputMapper::dump(String8& dump) {
dumpRawAxes(dump); dumpRawAxes(dump);
dumpCalibration(dump); dumpCalibration(dump);
dumpSurfaceLocked(dump); dumpSurfaceLocked(dump);
dump.appendFormat(INDENT3 "XPrecision: %0.3f\n", mLocked.xPrecision); dump.appendFormat(INDENT3 "Translation and Scaling Factors:");
dump.appendFormat(INDENT3 "YPrecision: %0.3f\n", mLocked.yPrecision); dump.appendFormat(INDENT4 "XOrigin: %d\n", mLocked.xOrigin);
dump.appendFormat(INDENT4 "YOrigin: %d\n", mLocked.yOrigin);
dump.appendFormat(INDENT4 "XScale: %0.3f\n", mLocked.xScale);
dump.appendFormat(INDENT4 "YScale: %0.3f\n", mLocked.yScale);
dump.appendFormat(INDENT4 "XPrecision: %0.3f\n", mLocked.xPrecision);
dump.appendFormat(INDENT4 "YPrecision: %0.3f\n", mLocked.yPrecision);
dump.appendFormat(INDENT4 "GeometricScale: %0.3f\n", mLocked.geometricScale);
dump.appendFormat(INDENT4 "ToolSizeLinearScale: %0.3f\n", mLocked.toolSizeLinearScale);
dump.appendFormat(INDENT4 "ToolSizeLinearBias: %0.3f\n", mLocked.toolSizeLinearBias);
dump.appendFormat(INDENT4 "ToolSizeAreaScale: %0.3f\n", mLocked.toolSizeAreaScale);
dump.appendFormat(INDENT4 "ToolSizeAreaBias: %0.3f\n", mLocked.toolSizeAreaBias);
dump.appendFormat(INDENT4 "PressureScale: %0.3f\n", mLocked.pressureScale);
dump.appendFormat(INDENT4 "SizeScale: %0.3f\n", mLocked.sizeScale);
dump.appendFormat(INDENT4 "OrientationSCale: %0.3f\n", mLocked.orientationScale);
} // release lock } // release lock
} }
@@ -1298,8 +1311,8 @@ void TouchInputMapper::initializeLocked() {
mLocked.orientedRanges.havePressure = false; mLocked.orientedRanges.havePressure = false;
mLocked.orientedRanges.haveSize = false; mLocked.orientedRanges.haveSize = false;
mLocked.orientedRanges.haveTouchArea = false; mLocked.orientedRanges.haveTouchSize = false;
mLocked.orientedRanges.haveToolArea = false; mLocked.orientedRanges.haveToolSize = false;
mLocked.orientedRanges.haveOrientation = false; mLocked.orientedRanges.haveOrientation = false;
} }
@@ -1428,8 +1441,8 @@ bool TouchInputMapper::configureSurfaceLocked() {
float diagonalSize = pythag(width, height); float diagonalSize = pythag(width, height);
// TouchMajor and TouchMinor factors. // TouchMajor and TouchMinor factors.
if (mCalibration.touchAreaCalibration != Calibration::TOUCH_AREA_CALIBRATION_NONE) { if (mCalibration.touchSizeCalibration != Calibration::TOUCH_SIZE_CALIBRATION_NONE) {
mLocked.orientedRanges.haveTouchArea = true; mLocked.orientedRanges.haveTouchSize = true;
mLocked.orientedRanges.touchMajor.min = 0; mLocked.orientedRanges.touchMajor.min = 0;
mLocked.orientedRanges.touchMajor.max = diagonalSize; mLocked.orientedRanges.touchMajor.max = diagonalSize;
mLocked.orientedRanges.touchMajor.flat = 0; mLocked.orientedRanges.touchMajor.flat = 0;
@@ -1438,23 +1451,46 @@ bool TouchInputMapper::configureSurfaceLocked() {
} }
// ToolMajor and ToolMinor factors. // ToolMajor and ToolMinor factors.
if (mCalibration.toolAreaCalibration != Calibration::TOOL_AREA_CALIBRATION_NONE) { mLocked.toolSizeLinearScale = 0;
mLocked.toolAreaLinearScale = 0; mLocked.toolSizeLinearBias = 0;
mLocked.toolAreaLinearBias = 0; mLocked.toolSizeAreaScale = 0;
if (mCalibration.toolAreaCalibration == Calibration::TOOL_AREA_CALIBRATION_LINEAR) { mLocked.toolSizeAreaBias = 0;
if (mCalibration.haveToolAreaLinearScale) { if (mCalibration.toolSizeCalibration != Calibration::TOOL_SIZE_CALIBRATION_NONE) {
mLocked.toolAreaLinearScale = mCalibration.toolAreaLinearScale; if (mCalibration.toolSizeCalibration == Calibration::TOOL_SIZE_CALIBRATION_LINEAR) {
if (mCalibration.haveToolSizeLinearScale) {
mLocked.toolSizeLinearScale = mCalibration.toolSizeLinearScale;
} else if (mRawAxes.toolMajor.valid && mRawAxes.toolMajor.maxValue != 0) { } else if (mRawAxes.toolMajor.valid && mRawAxes.toolMajor.maxValue != 0) {
mLocked.toolAreaLinearScale = float(min(width, height)) mLocked.toolSizeLinearScale = float(min(width, height))
/ mRawAxes.toolMajor.maxValue; / mRawAxes.toolMajor.maxValue;
} }
if (mCalibration.haveToolAreaLinearBias) { if (mCalibration.haveToolSizeLinearBias) {
mLocked.toolAreaLinearBias = mCalibration.toolAreaLinearBias; mLocked.toolSizeLinearBias = mCalibration.toolSizeLinearBias;
}
} else if (mCalibration.toolSizeCalibration ==
Calibration::TOOL_SIZE_CALIBRATION_AREA) {
if (mCalibration.haveToolSizeLinearScale) {
mLocked.toolSizeLinearScale = mCalibration.toolSizeLinearScale;
} else {
mLocked.toolSizeLinearScale = min(width, height);
}
if (mCalibration.haveToolSizeLinearBias) {
mLocked.toolSizeLinearBias = mCalibration.toolSizeLinearBias;
}
if (mCalibration.haveToolSizeAreaScale) {
mLocked.toolSizeAreaScale = mCalibration.toolSizeAreaScale;
} else if (mRawAxes.toolMajor.valid && mRawAxes.toolMajor.maxValue != 0) {
mLocked.toolSizeAreaScale = 1.0f / mRawAxes.toolMajor.maxValue;
}
if (mCalibration.haveToolSizeAreaBias) {
mLocked.toolSizeAreaBias = mCalibration.toolSizeAreaBias;
} }
} }
mLocked.orientedRanges.haveToolArea = true; mLocked.orientedRanges.haveToolSize = true;
mLocked.orientedRanges.toolMajor.min = 0; mLocked.orientedRanges.toolMajor.min = 0;
mLocked.orientedRanges.toolMajor.max = diagonalSize; mLocked.orientedRanges.toolMajor.max = diagonalSize;
mLocked.orientedRanges.toolMajor.flat = 0; mLocked.orientedRanges.toolMajor.flat = 0;
@@ -1463,6 +1499,7 @@ bool TouchInputMapper::configureSurfaceLocked() {
} }
// Pressure factors. // Pressure factors.
mLocked.pressureScale = 0;
if (mCalibration.pressureCalibration != Calibration::PRESSURE_CALIBRATION_NONE) { if (mCalibration.pressureCalibration != Calibration::PRESSURE_CALIBRATION_NONE) {
RawAbsoluteAxisInfo rawPressureAxis; RawAbsoluteAxisInfo rawPressureAxis;
switch (mCalibration.pressureSource) { switch (mCalibration.pressureSource) {
@@ -1476,7 +1513,6 @@ bool TouchInputMapper::configureSurfaceLocked() {
rawPressureAxis.clear(); rawPressureAxis.clear();
} }
mLocked.pressureScale = 0;
if (mCalibration.pressureCalibration == Calibration::PRESSURE_CALIBRATION_PHYSICAL if (mCalibration.pressureCalibration == Calibration::PRESSURE_CALIBRATION_PHYSICAL
|| mCalibration.pressureCalibration || mCalibration.pressureCalibration
== Calibration::PRESSURE_CALIBRATION_AMPLITUDE) { == Calibration::PRESSURE_CALIBRATION_AMPLITUDE) {
@@ -1495,8 +1531,8 @@ bool TouchInputMapper::configureSurfaceLocked() {
} }
// Size factors. // Size factors.
mLocked.sizeScale = 0;
if (mCalibration.sizeCalibration != Calibration::SIZE_CALIBRATION_NONE) { if (mCalibration.sizeCalibration != Calibration::SIZE_CALIBRATION_NONE) {
mLocked.sizeScale = 0;
if (mCalibration.sizeCalibration == Calibration::SIZE_CALIBRATION_NORMALIZED) { if (mCalibration.sizeCalibration == Calibration::SIZE_CALIBRATION_NORMALIZED) {
if (mRawAxes.toolMajor.valid && mRawAxes.toolMajor.maxValue != 0) { if (mRawAxes.toolMajor.valid && mRawAxes.toolMajor.maxValue != 0) {
mLocked.sizeScale = 1.0f / mRawAxes.toolMajor.maxValue; mLocked.sizeScale = 1.0f / mRawAxes.toolMajor.maxValue;
@@ -1511,8 +1547,8 @@ bool TouchInputMapper::configureSurfaceLocked() {
} }
// Orientation // Orientation
mLocked.orientationScale = 0;
if (mCalibration.orientationCalibration != Calibration::ORIENTATION_CALIBRATION_NONE) { if (mCalibration.orientationCalibration != Calibration::ORIENTATION_CALIBRATION_NONE) {
mLocked.orientationScale = 0;
if (mCalibration.orientationCalibration if (mCalibration.orientationCalibration
== Calibration::ORIENTATION_CALIBRATION_INTERPOLATED) { == Calibration::ORIENTATION_CALIBRATION_INTERPOLATED) {
if (mRawAxes.orientation.valid && mRawAxes.orientation.maxValue != 0) { if (mRawAxes.orientation.valid && mRawAxes.orientation.maxValue != 0) {
@@ -1647,49 +1683,55 @@ void TouchInputMapper::parseCalibration() {
const InputDeviceCalibration& in = getDevice()->getCalibration(); const InputDeviceCalibration& in = getDevice()->getCalibration();
Calibration& out = mCalibration; Calibration& out = mCalibration;
// Touch Area // Touch Size
out.touchAreaCalibration = Calibration::TOUCH_AREA_CALIBRATION_DEFAULT; out.touchSizeCalibration = Calibration::TOUCH_SIZE_CALIBRATION_DEFAULT;
String8 touchAreaCalibrationString; String8 touchSizeCalibrationString;
if (in.tryGetProperty(String8("touch.touchArea.calibration"), touchAreaCalibrationString)) { if (in.tryGetProperty(String8("touch.touchSize.calibration"), touchSizeCalibrationString)) {
if (touchAreaCalibrationString == "none") { if (touchSizeCalibrationString == "none") {
out.touchAreaCalibration = Calibration::TOUCH_AREA_CALIBRATION_NONE; out.touchSizeCalibration = Calibration::TOUCH_SIZE_CALIBRATION_NONE;
} else if (touchAreaCalibrationString == "geometric") { } else if (touchSizeCalibrationString == "geometric") {
out.touchAreaCalibration = Calibration::TOUCH_AREA_CALIBRATION_GEOMETRIC; out.touchSizeCalibration = Calibration::TOUCH_SIZE_CALIBRATION_GEOMETRIC;
} else if (touchAreaCalibrationString == "pressure") { } else if (touchSizeCalibrationString == "pressure") {
out.touchAreaCalibration = Calibration::TOUCH_AREA_CALIBRATION_PRESSURE; out.touchSizeCalibration = Calibration::TOUCH_SIZE_CALIBRATION_PRESSURE;
} else if (touchAreaCalibrationString != "default") { } else if (touchSizeCalibrationString != "default") {
LOGW("Invalid value for touch.touchArea.calibration: '%s'", LOGW("Invalid value for touch.touchSize.calibration: '%s'",
touchAreaCalibrationString.string()); touchSizeCalibrationString.string());
} }
} }
// Tool Area // Tool Size
out.toolAreaCalibration = Calibration::TOOL_AREA_CALIBRATION_DEFAULT; out.toolSizeCalibration = Calibration::TOOL_SIZE_CALIBRATION_DEFAULT;
String8 toolAreaCalibrationString; String8 toolSizeCalibrationString;
if (in.tryGetProperty(String8("tool.toolArea.calibration"), toolAreaCalibrationString)) { if (in.tryGetProperty(String8("touch.toolSize.calibration"), toolSizeCalibrationString)) {
if (toolAreaCalibrationString == "none") { if (toolSizeCalibrationString == "none") {
out.toolAreaCalibration = Calibration::TOOL_AREA_CALIBRATION_NONE; out.toolSizeCalibration = Calibration::TOOL_SIZE_CALIBRATION_NONE;
} else if (toolAreaCalibrationString == "geometric") { } else if (toolSizeCalibrationString == "geometric") {
out.toolAreaCalibration = Calibration::TOOL_AREA_CALIBRATION_GEOMETRIC; out.toolSizeCalibration = Calibration::TOOL_SIZE_CALIBRATION_GEOMETRIC;
} else if (toolAreaCalibrationString == "linear") { } else if (toolSizeCalibrationString == "linear") {
out.toolAreaCalibration = Calibration::TOOL_AREA_CALIBRATION_LINEAR; out.toolSizeCalibration = Calibration::TOOL_SIZE_CALIBRATION_LINEAR;
} else if (toolAreaCalibrationString != "default") { } else if (toolSizeCalibrationString == "area") {
LOGW("Invalid value for tool.toolArea.calibration: '%s'", out.toolSizeCalibration = Calibration::TOOL_SIZE_CALIBRATION_AREA;
toolAreaCalibrationString.string()); } else if (toolSizeCalibrationString != "default") {
LOGW("Invalid value for touch.toolSize.calibration: '%s'",
toolSizeCalibrationString.string());
} }
} }
out.haveToolAreaLinearScale = in.tryGetProperty(String8("touch.toolArea.linearScale"), out.haveToolSizeLinearScale = in.tryGetProperty(String8("touch.toolSize.linearScale"),
out.toolAreaLinearScale); out.toolSizeLinearScale);
out.haveToolAreaLinearBias = in.tryGetProperty(String8("touch.toolArea.linearBias"), out.haveToolSizeLinearBias = in.tryGetProperty(String8("touch.toolSize.linearBias"),
out.toolAreaLinearBias); out.toolSizeLinearBias);
out.haveToolAreaIsSummed = in.tryGetProperty(String8("touch.toolArea.isSummed"), out.haveToolSizeAreaScale = in.tryGetProperty(String8("touch.toolSize.areaScale"),
out.toolAreaIsSummed); out.toolSizeAreaScale);
out.haveToolSizeAreaBias = in.tryGetProperty(String8("touch.toolSize.areaBias"),
out.toolSizeAreaBias);
out.haveToolSizeIsSummed = in.tryGetProperty(String8("touch.toolSize.isSummed"),
out.toolSizeIsSummed);
// Pressure // Pressure
out.pressureCalibration = Calibration::PRESSURE_CALIBRATION_DEFAULT; out.pressureCalibration = Calibration::PRESSURE_CALIBRATION_DEFAULT;
String8 pressureCalibrationString; String8 pressureCalibrationString;
if (in.tryGetProperty(String8("tool.pressure.calibration"), pressureCalibrationString)) { if (in.tryGetProperty(String8("touch.pressure.calibration"), pressureCalibrationString)) {
if (pressureCalibrationString == "none") { if (pressureCalibrationString == "none") {
out.pressureCalibration = Calibration::PRESSURE_CALIBRATION_NONE; out.pressureCalibration = Calibration::PRESSURE_CALIBRATION_NONE;
} else if (pressureCalibrationString == "physical") { } else if (pressureCalibrationString == "physical") {
@@ -1697,7 +1739,7 @@ void TouchInputMapper::parseCalibration() {
} else if (pressureCalibrationString == "amplitude") { } else if (pressureCalibrationString == "amplitude") {
out.pressureCalibration = Calibration::PRESSURE_CALIBRATION_AMPLITUDE; out.pressureCalibration = Calibration::PRESSURE_CALIBRATION_AMPLITUDE;
} else if (pressureCalibrationString != "default") { } else if (pressureCalibrationString != "default") {
LOGW("Invalid value for tool.pressure.calibration: '%s'", LOGW("Invalid value for touch.pressure.calibration: '%s'",
pressureCalibrationString.string()); pressureCalibrationString.string());
} }
} }
@@ -1721,13 +1763,13 @@ void TouchInputMapper::parseCalibration() {
// Size // Size
out.sizeCalibration = Calibration::SIZE_CALIBRATION_DEFAULT; out.sizeCalibration = Calibration::SIZE_CALIBRATION_DEFAULT;
String8 sizeCalibrationString; String8 sizeCalibrationString;
if (in.tryGetProperty(String8("tool.size.calibration"), sizeCalibrationString)) { if (in.tryGetProperty(String8("touch.size.calibration"), sizeCalibrationString)) {
if (sizeCalibrationString == "none") { if (sizeCalibrationString == "none") {
out.sizeCalibration = Calibration::SIZE_CALIBRATION_NONE; out.sizeCalibration = Calibration::SIZE_CALIBRATION_NONE;
} else if (sizeCalibrationString == "normalized") { } else if (sizeCalibrationString == "normalized") {
out.sizeCalibration = Calibration::SIZE_CALIBRATION_NORMALIZED; out.sizeCalibration = Calibration::SIZE_CALIBRATION_NORMALIZED;
} else if (sizeCalibrationString != "default") { } else if (sizeCalibrationString != "default") {
LOGW("Invalid value for tool.size.calibration: '%s'", LOGW("Invalid value for touch.size.calibration: '%s'",
sizeCalibrationString.string()); sizeCalibrationString.string());
} }
} }
@@ -1735,13 +1777,13 @@ void TouchInputMapper::parseCalibration() {
// Orientation // Orientation
out.orientationCalibration = Calibration::ORIENTATION_CALIBRATION_DEFAULT; out.orientationCalibration = Calibration::ORIENTATION_CALIBRATION_DEFAULT;
String8 orientationCalibrationString; String8 orientationCalibrationString;
if (in.tryGetProperty(String8("tool.orientation.calibration"), orientationCalibrationString)) { if (in.tryGetProperty(String8("touch.orientation.calibration"), orientationCalibrationString)) {
if (orientationCalibrationString == "none") { if (orientationCalibrationString == "none") {
out.orientationCalibration = Calibration::ORIENTATION_CALIBRATION_NONE; out.orientationCalibration = Calibration::ORIENTATION_CALIBRATION_NONE;
} else if (orientationCalibrationString == "interpolated") { } else if (orientationCalibrationString == "interpolated") {
out.orientationCalibration = Calibration::ORIENTATION_CALIBRATION_INTERPOLATED; out.orientationCalibration = Calibration::ORIENTATION_CALIBRATION_INTERPOLATED;
} else if (orientationCalibrationString != "default") { } else if (orientationCalibrationString != "default") {
LOGW("Invalid value for tool.orientation.calibration: '%s'", LOGW("Invalid value for touch.orientation.calibration: '%s'",
orientationCalibrationString.string()); orientationCalibrationString.string());
} }
} }
@@ -1789,13 +1831,13 @@ void TouchInputMapper::resolveCalibration() {
break; break;
} }
// Tool Area // Tool Size
switch (mCalibration.toolAreaCalibration) { switch (mCalibration.toolSizeCalibration) {
case Calibration::TOOL_AREA_CALIBRATION_DEFAULT: case Calibration::TOOL_SIZE_CALIBRATION_DEFAULT:
if (mRawAxes.toolMajor.valid) { if (mRawAxes.toolMajor.valid) {
mCalibration.toolAreaCalibration = Calibration::TOOL_AREA_CALIBRATION_LINEAR; mCalibration.toolSizeCalibration = Calibration::TOOL_SIZE_CALIBRATION_LINEAR;
} else { } else {
mCalibration.toolAreaCalibration = Calibration::TOOL_AREA_CALIBRATION_NONE; mCalibration.toolSizeCalibration = Calibration::TOOL_SIZE_CALIBRATION_NONE;
} }
break; break;
@@ -1803,14 +1845,14 @@ void TouchInputMapper::resolveCalibration() {
break; break;
} }
// Touch Area // Touch Size
switch (mCalibration.touchAreaCalibration) { switch (mCalibration.touchSizeCalibration) {
case Calibration::TOUCH_AREA_CALIBRATION_DEFAULT: case Calibration::TOUCH_SIZE_CALIBRATION_DEFAULT:
if (mCalibration.pressureCalibration != Calibration::PRESSURE_CALIBRATION_NONE if (mCalibration.pressureCalibration != Calibration::PRESSURE_CALIBRATION_NONE
&& mCalibration.toolAreaCalibration != Calibration::TOOL_AREA_CALIBRATION_NONE) { && mCalibration.toolSizeCalibration != Calibration::TOOL_SIZE_CALIBRATION_NONE) {
mCalibration.touchAreaCalibration = Calibration::TOUCH_AREA_CALIBRATION_PRESSURE; mCalibration.touchSizeCalibration = Calibration::TOUCH_SIZE_CALIBRATION_PRESSURE;
} else { } else {
mCalibration.touchAreaCalibration = Calibration::TOUCH_AREA_CALIBRATION_NONE; mCalibration.touchSizeCalibration = Calibration::TOUCH_SIZE_CALIBRATION_NONE;
} }
break; break;
@@ -1850,49 +1892,62 @@ void TouchInputMapper::resolveCalibration() {
void TouchInputMapper::dumpCalibration(String8& dump) { void TouchInputMapper::dumpCalibration(String8& dump) {
dump.append(INDENT3 "Calibration:\n"); dump.append(INDENT3 "Calibration:\n");
// Touch Area // Touch Size
switch (mCalibration.touchAreaCalibration) { switch (mCalibration.touchSizeCalibration) {
case Calibration::TOUCH_AREA_CALIBRATION_NONE: case Calibration::TOUCH_SIZE_CALIBRATION_NONE:
dump.append(INDENT4 "touch.touchArea.calibration: none\n"); dump.append(INDENT4 "touch.touchSize.calibration: none\n");
break; break;
case Calibration::TOUCH_AREA_CALIBRATION_GEOMETRIC: case Calibration::TOUCH_SIZE_CALIBRATION_GEOMETRIC:
dump.append(INDENT4 "touch.touchArea.calibration: geometric\n"); dump.append(INDENT4 "touch.touchSize.calibration: geometric\n");
break; break;
case Calibration::TOUCH_AREA_CALIBRATION_PRESSURE: case Calibration::TOUCH_SIZE_CALIBRATION_PRESSURE:
dump.append(INDENT4 "touch.touchArea.calibration: pressure\n"); dump.append(INDENT4 "touch.touchSize.calibration: pressure\n");
break; break;
default: default:
assert(false); assert(false);
} }
// Tool Area // Tool Size
switch (mCalibration.toolAreaCalibration) { switch (mCalibration.toolSizeCalibration) {
case Calibration::TOOL_AREA_CALIBRATION_NONE: case Calibration::TOOL_SIZE_CALIBRATION_NONE:
dump.append(INDENT4 "touch.toolArea.calibration: none\n"); dump.append(INDENT4 "touch.toolSize.calibration: none\n");
break; break;
case Calibration::TOOL_AREA_CALIBRATION_GEOMETRIC: case Calibration::TOOL_SIZE_CALIBRATION_GEOMETRIC:
dump.append(INDENT4 "touch.toolArea.calibration: geometric\n"); dump.append(INDENT4 "touch.toolSize.calibration: geometric\n");
break; break;
case Calibration::TOOL_AREA_CALIBRATION_LINEAR: case Calibration::TOOL_SIZE_CALIBRATION_LINEAR:
dump.append(INDENT4 "touch.toolArea.calibration: linear\n"); dump.append(INDENT4 "touch.toolSize.calibration: linear\n");
break;
case Calibration::TOOL_SIZE_CALIBRATION_AREA:
dump.append(INDENT4 "touch.toolSize.calibration: area\n");
break; break;
default: default:
assert(false); assert(false);
} }
if (mCalibration.haveToolAreaLinearScale) { if (mCalibration.haveToolSizeLinearScale) {
dump.appendFormat(INDENT4 "touch.toolArea.linearScale: %0.3f\n", dump.appendFormat(INDENT4 "touch.toolSize.linearScale: %0.3f\n",
mCalibration.toolAreaLinearScale); mCalibration.toolSizeLinearScale);
} }
if (mCalibration.haveToolAreaLinearBias) { if (mCalibration.haveToolSizeLinearBias) {
dump.appendFormat(INDENT4 "touch.toolArea.linearBias: %0.3f\n", dump.appendFormat(INDENT4 "touch.toolSize.linearBias: %0.3f\n",
mCalibration.toolAreaLinearBias); mCalibration.toolSizeLinearBias);
} }
if (mCalibration.haveToolAreaIsSummed) { if (mCalibration.haveToolSizeAreaScale) {
dump.appendFormat(INDENT4 "touch.toolArea.isSummed: %d\n", dump.appendFormat(INDENT4 "touch.toolSize.areaScale: %0.3f\n",
mCalibration.toolAreaIsSummed); mCalibration.toolSizeAreaScale);
}
if (mCalibration.haveToolSizeAreaBias) {
dump.appendFormat(INDENT4 "touch.toolSize.areaBias: %0.3f\n",
mCalibration.toolSizeAreaBias);
}
if (mCalibration.haveToolSizeIsSummed) {
dump.appendFormat(INDENT4 "touch.toolSize.isSummed: %d\n",
mCalibration.toolSizeIsSummed);
} }
// Pressure // Pressure
@@ -2207,8 +2262,8 @@ void TouchInputMapper::dispatchTouch(nsecs_t when, uint32_t policyFlags,
// ToolMajor and ToolMinor // ToolMajor and ToolMinor
float toolMajor, toolMinor; float toolMajor, toolMinor;
switch (mCalibration.toolAreaCalibration) { switch (mCalibration.toolSizeCalibration) {
case Calibration::TOOL_AREA_CALIBRATION_GEOMETRIC: case Calibration::TOOL_SIZE_CALIBRATION_GEOMETRIC:
toolMajor = in.toolMajor * mLocked.geometricScale; toolMajor = in.toolMajor * mLocked.geometricScale;
if (mRawAxes.toolMinor.valid) { if (mRawAxes.toolMinor.valid) {
toolMinor = in.toolMinor * mLocked.geometricScale; toolMinor = in.toolMinor * mLocked.geometricScale;
@@ -2216,26 +2271,36 @@ void TouchInputMapper::dispatchTouch(nsecs_t when, uint32_t policyFlags,
toolMinor = toolMajor; toolMinor = toolMajor;
} }
break; break;
case Calibration::TOOL_AREA_CALIBRATION_LINEAR: case Calibration::TOOL_SIZE_CALIBRATION_LINEAR:
toolMajor = in.toolMajor != 0 toolMajor = in.toolMajor != 0
? in.toolMajor * mLocked.toolAreaLinearScale + mLocked.toolAreaLinearBias ? in.toolMajor * mLocked.toolSizeLinearScale + mLocked.toolSizeLinearBias
: 0; : 0;
if (mRawAxes.toolMinor.valid) { if (mRawAxes.toolMinor.valid) {
toolMinor = in.toolMinor != 0 toolMinor = in.toolMinor != 0
? in.toolMinor * mLocked.toolAreaLinearScale ? in.toolMinor * mLocked.toolSizeLinearScale
+ mLocked.toolAreaLinearBias + mLocked.toolSizeLinearBias
: 0; : 0;
} else { } else {
toolMinor = toolMajor; toolMinor = toolMajor;
} }
break; break;
case Calibration::TOOL_SIZE_CALIBRATION_AREA:
if (in.toolMajor != 0) {
float diameter = sqrtf(in.toolMajor
* mLocked.toolSizeAreaScale + mLocked.toolSizeAreaBias);
toolMajor = diameter * mLocked.toolSizeLinearScale + mLocked.toolSizeLinearBias;
} else {
toolMajor = 0;
}
toolMinor = toolMajor;
break;
default: default:
toolMajor = 0; toolMajor = 0;
toolMinor = 0; toolMinor = 0;
break; break;
} }
if (mCalibration.haveToolAreaIsSummed && mCalibration.toolAreaIsSummed) { if (mCalibration.haveToolSizeIsSummed && mCalibration.toolSizeIsSummed) {
toolMajor /= pointerCount; toolMajor /= pointerCount;
toolMinor /= pointerCount; toolMinor /= pointerCount;
} }
@@ -2266,8 +2331,8 @@ void TouchInputMapper::dispatchTouch(nsecs_t when, uint32_t policyFlags,
// TouchMajor and TouchMinor // TouchMajor and TouchMinor
float touchMajor, touchMinor; float touchMajor, touchMinor;
switch (mCalibration.touchAreaCalibration) { switch (mCalibration.touchSizeCalibration) {
case Calibration::TOUCH_AREA_CALIBRATION_GEOMETRIC: case Calibration::TOUCH_SIZE_CALIBRATION_GEOMETRIC:
touchMajor = in.touchMajor * mLocked.geometricScale; touchMajor = in.touchMajor * mLocked.geometricScale;
if (mRawAxes.touchMinor.valid) { if (mRawAxes.touchMinor.valid) {
touchMinor = in.touchMinor * mLocked.geometricScale; touchMinor = in.touchMinor * mLocked.geometricScale;
@@ -2275,7 +2340,7 @@ void TouchInputMapper::dispatchTouch(nsecs_t when, uint32_t policyFlags,
touchMinor = touchMajor; touchMinor = touchMajor;
} }
break; break;
case Calibration::TOUCH_AREA_CALIBRATION_PRESSURE: case Calibration::TOUCH_SIZE_CALIBRATION_PRESSURE:
touchMajor = toolMajor * pressure; touchMajor = toolMajor * pressure;
touchMinor = toolMinor * pressure; touchMinor = toolMinor * pressure;
break; break;