Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 50763119 authored by Jeff Brown's avatar Jeff Brown Committed by Android Git Automerger
Browse files

am e0c12c88: Merge "Move verbose logging of device capabilities to dumpsys." into gingerbread 

Merge commit 'e0c12c8803a7e2457098afc5dbf00e501d725fa0' into gingerbread-plus-aosp

* commit 'e0c12c8803a7e2457098afc5dbf00e501d725fa0':
  Move verbose logging of device capabilities to dumpsys.
parents c2b33157 39e1275d

include/ui/InputReader.h

+10 −7
Original line number Diff line number Diff line
@@ -308,9 +308,6 @@ private: 
            GetStateFunc getStateFunc);

    bool markSupportedKeyCodes(int32_t deviceId, uint32_t sourceMask, size_t numCodes,

            const int32_t* keyCodes, uint8_t* outFlags);



    // dump state

    void dumpDeviceInfo(String8& dump);

};
@@ -340,6 +337,7 @@ public: 


    inline bool isIgnored() { return mMappers.isEmpty(); }



    void dump(String8& dump);

    void addMapper(InputMapper* mapper);

    void configure();

    void reset();
@@ -393,6 +391,7 @@ public: 


    virtual uint32_t getSources() = 0;

    virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);

    virtual void dump(String8& dump);

    virtual void configure();

    virtual void reset();

    virtual void process(const RawEvent* rawEvent) = 0;
@@ -436,6 +435,7 @@ public: 


    virtual uint32_t getSources();

    virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);

    virtual void dump(String8& dump);

    virtual void reset();

    virtual void process(const RawEvent* rawEvent);
@@ -484,6 +484,7 @@ public: 


    virtual uint32_t getSources();

    virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);

    virtual void dump(String8& dump);

    virtual void reset();

    virtual void process(const RawEvent* rawEvent);
@@ -540,6 +541,7 @@ public: 


    virtual uint32_t getSources();

    virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);

    virtual void dump(String8& dump);

    virtual void configure();

    virtual void reset();
@@ -761,15 +763,16 @@ protected: 
    } mLocked;



    virtual void configureParameters();

    virtual void logParameters();

    virtual void dumpParameters(String8& dump);

    virtual void configureRawAxes();

    virtual void logRawAxes();

    virtual void dumpRawAxes(String8& dump);

    virtual bool configureSurfaceLocked();

    virtual void logMotionRangesLocked();

    virtual void dumpSurfaceLocked(String8& dump);

    virtual void configureVirtualKeysLocked();

    virtual void dumpVirtualKeysLocked(String8& dump);

    virtual void parseCalibration();

    virtual void resolveCalibration();

    virtual void logCalibration();

    virtual void dumpCalibration(String8& dump);



    enum TouchResult {

        // Dispatch the touch normally.

libs/ui/InputReader.cpp

+161 −138
Original line number Diff line number Diff line
@@ -33,6 +33,9 @@ 
#include <math.h>



#define INDENT "  "

#define INDENT2 "    "

#define INDENT3 "      "

#define INDENT4 "        "



namespace android {
@@ -63,6 +66,10 @@ inline static float pythag(float x, float y) { 
    return sqrtf(x * x + y * y);

}



static inline const char* toString(bool value) {

    return value ? "true" : "false";

}





int32_t updateMetaState(int32_t keyCode, bool down, int32_t oldMetaState) {

    int32_t mask;
@@ -236,16 +243,14 @@ void InputReader::addDevice(nsecs_t when, int32_t deviceId) { 
    String8 name = mEventHub->getDeviceName(deviceId);

    uint32_t classes = mEventHub->getDeviceClasses(deviceId);



    // Write a log message about the added device as a heading for subsequent log messages.

    LOGI("Device added: id=0x%x, name=%s", deviceId, name.string());



    InputDevice* device = createDevice(deviceId, name, classes);

    device->configure();



    if (device->isIgnored()) {

        LOGI(INDENT "Sources: none (device is ignored)");

        LOGI("Device added: id=0x%x, name=%s (ignored non-input device)", deviceId, name.string());

    } else {

        LOGI(INDENT "Sources: 0x%08x", device->getSources());

        LOGI("Device added: id=0x%x, name=%s, sources=%08x", deviceId, name.string(),

                device->getSources());

    }



    bool added = false;
@@ -287,7 +292,6 @@ void InputReader::removeDevice(nsecs_t when, int32_t deviceId) { 
        return;

    }



    // Write a log message about the removed device as a heading for subsequent log messages.

    if (device->isIgnored()) {

        LOGI("Device removed: id=0x%x, name=%s (ignored non-input device)",

                device->getId(), device->getName().string());
@@ -571,59 +575,15 @@ bool InputReader::markSupportedKeyCodes(int32_t deviceId, uint32_t sourceMask, s 
}



void InputReader::dump(String8& dump) {

    dumpDeviceInfo(dump);

}



static void dumpMotionRange(String8& dump,

        const char* name, const InputDeviceInfo::MotionRange* range) {

    if (range) {

        dump.appendFormat("      %s = { min: %0.3f, max: %0.3f, flat: %0.3f, fuzz: %0.3f }\n",

                name, range->min, range->max, range->flat, range->fuzz);

    }

}



#define DUMP_MOTION_RANGE(range) \

    dumpMotionRange(dump, #range, deviceInfo.getMotionRange(AINPUT_MOTION_RANGE_##range));



void InputReader::dumpDeviceInfo(String8& dump) {

    Vector<int32_t> deviceIds;

    getInputDeviceIds(deviceIds);



    InputDeviceInfo deviceInfo;

    for (size_t i = 0; i < deviceIds.size(); i++) {

        int32_t deviceId = deviceIds[i];



        status_t result = getInputDeviceInfo(deviceId, & deviceInfo);

        if (result == NAME_NOT_FOUND) {

            continue;

        } else if (result != OK) {

            dump.appendFormat("  ** Unexpected error %d getting information about input devices.\n",

                    result);

            continue;

        }



        dump.appendFormat("  Device %d: '%s'\n",

                deviceInfo.getId(), deviceInfo.getName().string());

        dump.appendFormat("    sources = 0x%08x\n",

                deviceInfo.getSources());

        dump.appendFormat("    keyboardType = %d\n",

                deviceInfo.getKeyboardType());

    { // acquire device registry reader lock

        RWLock::AutoRLock _rl(mDeviceRegistryLock);



        dump.append("    motion ranges:\n");

        DUMP_MOTION_RANGE(X);

        DUMP_MOTION_RANGE(Y);

        DUMP_MOTION_RANGE(PRESSURE);

        DUMP_MOTION_RANGE(SIZE);

        DUMP_MOTION_RANGE(TOUCH_MAJOR);

        DUMP_MOTION_RANGE(TOUCH_MINOR);

        DUMP_MOTION_RANGE(TOOL_MAJOR);

        DUMP_MOTION_RANGE(TOOL_MINOR);

        DUMP_MOTION_RANGE(ORIENTATION);

        for (size_t i = 0; i < mDevices.size(); i++) {

            mDevices.valueAt(i)->dump(dump);

        }

    } // release device registy reader lock

}



#undef DUMP_MOTION_RANGE





// --- InputReaderThread ---
@@ -654,6 +614,43 @@ InputDevice::~InputDevice() { 
    mMappers.clear();

}



static void dumpMotionRange(String8& dump, const InputDeviceInfo& deviceInfo,

        int32_t rangeType, const char* name) {

    const InputDeviceInfo::MotionRange* range = deviceInfo.getMotionRange(rangeType);

    if (range) {

        dump.appendFormat(INDENT3 "%s: min=%0.3f, max=%0.3f, flat=%0.3f, fuzz=%0.3f\n",

                name, range->min, range->max, range->flat, range->fuzz);

    }

}



void InputDevice::dump(String8& dump) {

    InputDeviceInfo deviceInfo;

    getDeviceInfo(& deviceInfo);



    dump.appendFormat(INDENT "Device 0x%x: %s\n", deviceInfo.getId(),

            deviceInfo.getName().string());

    dump.appendFormat(INDENT2 "Sources: 0x%08x\n", deviceInfo.getSources());

    dump.appendFormat(INDENT2 "KeyboardType: %d\n", deviceInfo.getKeyboardType());

    if (!deviceInfo.getMotionRanges().isEmpty()) {

        dump.append(INDENT2 "Motion Ranges:\n");

        dumpMotionRange(dump, deviceInfo, AINPUT_MOTION_RANGE_X, "X");

        dumpMotionRange(dump, deviceInfo, AINPUT_MOTION_RANGE_Y, "Y");

        dumpMotionRange(dump, deviceInfo, AINPUT_MOTION_RANGE_PRESSURE, "Pressure");

        dumpMotionRange(dump, deviceInfo, AINPUT_MOTION_RANGE_SIZE, "Size");

        dumpMotionRange(dump, deviceInfo, AINPUT_MOTION_RANGE_TOUCH_MAJOR, "TouchMajor");

        dumpMotionRange(dump, deviceInfo, AINPUT_MOTION_RANGE_TOUCH_MINOR, "TouchMinor");

        dumpMotionRange(dump, deviceInfo, AINPUT_MOTION_RANGE_TOOL_MAJOR, "ToolMajor");

        dumpMotionRange(dump, deviceInfo, AINPUT_MOTION_RANGE_TOOL_MINOR, "ToolMinor");

        dumpMotionRange(dump, deviceInfo, AINPUT_MOTION_RANGE_ORIENTATION, "Orientation");

    }



    size_t numMappers = mMappers.size();

    for (size_t i = 0; i < numMappers; i++) {

        InputMapper* mapper = mMappers[i];

        mapper->dump(dump);

    }

}



void InputDevice::addMapper(InputMapper* mapper) {

    mMappers.add(mapper);

}
@@ -763,6 +760,9 @@ void InputMapper::populateDeviceInfo(InputDeviceInfo* info) { 
    info->addSource(getSources());

}



void InputMapper::dump(String8& dump) {

}



void InputMapper::configure() {

}
@@ -856,6 +856,19 @@ void KeyboardInputMapper::populateDeviceInfo(InputDeviceInfo* info) { 
    info->setKeyboardType(mKeyboardType);

}



void KeyboardInputMapper::dump(String8& dump) {

    { // acquire lock

        AutoMutex _l(mLock);

        dump.append(INDENT2 "Keyboard Input Mapper:\n");

        dump.appendFormat(INDENT3 "AssociatedDisplayId: %d\n", mAssociatedDisplayId);

        dump.appendFormat(INDENT3 "Sources: 0x%x\n", mSources);

        dump.appendFormat(INDENT3 "KeyboardType: %d\n", mKeyboardType);

        dump.appendFormat(INDENT3 "KeyDowns: %d keys currently down\n", mLocked.keyDowns.size());

        dump.appendFormat(INDENT3 "MetaState: 0x%0x\n", mLocked.metaState);

        dump.appendFormat(INDENT3 "DownTime: %lld\n", mLocked.downTime);

    } // release lock

}



void KeyboardInputMapper::reset() {

    for (;;) {

        int32_t keyCode, scanCode;
@@ -1044,6 +1057,18 @@ void TrackballInputMapper::populateDeviceInfo(InputDeviceInfo* info) { 
    info->addMotionRange(AINPUT_MOTION_RANGE_Y, -1.0f, 1.0f, 0.0f, mYScale);

}



void TrackballInputMapper::dump(String8& dump) {

    { // acquire lock

        AutoMutex _l(mLock);

        dump.append(INDENT2 "Trackball Input Mapper:\n");

        dump.appendFormat(INDENT3 "AssociatedDisplayId: %d\n", mAssociatedDisplayId);

        dump.appendFormat(INDENT3 "XPrecision: %0.3f\n", mXPrecision);

        dump.appendFormat(INDENT3 "YPrecision: %0.3f\n", mYPrecision);

        dump.appendFormat(INDENT3 "Down: %s\n", toString(mLocked.down));

        dump.appendFormat(INDENT3 "DownTime: %lld\n", mLocked.downTime);

    } // release lock

}



void TrackballInputMapper::initializeLocked() {

    mAccumulator.clear();
@@ -1275,6 +1300,21 @@ void TouchInputMapper::populateDeviceInfo(InputDeviceInfo* info) { 
    } // release lock

}



void TouchInputMapper::dump(String8& dump) {

    { // acquire lock

        AutoMutex _l(mLock);

        dump.append(INDENT2 "Touch Input Mapper:\n");

        dump.appendFormat(INDENT3 "AssociatedDisplayId: %d\n", mAssociatedDisplayId);

        dumpParameters(dump);

        dumpVirtualKeysLocked(dump);

        dumpRawAxes(dump);

        dumpCalibration(dump);

        dumpSurfaceLocked(dump);

        dump.appendFormat(INDENT3 "XPrecision: %0.3f\n", mLocked.xPrecision);

        dump.appendFormat(INDENT3 "YPrecision: %0.3f\n", mLocked.yPrecision);

    } // release lock

}



void TouchInputMapper::initializeLocked() {

    mCurrentTouch.clear();

    mLastTouch.clear();
@@ -1301,16 +1341,13 @@ void TouchInputMapper::configure() { 


    // Configure basic parameters.

    configureParameters();

    logParameters();



    // Configure absolute axis information.

    configureRawAxes();

    logRawAxes();



    // Prepare input device calibration.

    parseCalibration();

    resolveCalibration();

    logCalibration();



    { // acquire lock

        AutoMutex _l(mLock);
@@ -1326,16 +1363,13 @@ void TouchInputMapper::configureParameters() { 
    mParameters.useJumpyTouchFilter = getPolicy()->filterJumpyTouchEvents();

}



void TouchInputMapper::logParameters() {

    if (mParameters.useBadTouchFilter) {

        LOGI(INDENT "Bad touch filter enabled.");

    }

    if (mParameters.useAveragingTouchFilter) {

        LOGI(INDENT "Averaging touch filter enabled.");

    }

    if (mParameters.useJumpyTouchFilter) {

        LOGI(INDENT "Jumpy touch filter enabled.");

    }

void TouchInputMapper::dumpParameters(String8& dump) {

    dump.appendFormat(INDENT3 "UseBadTouchFilter: %s\n",

            toString(mParameters.useBadTouchFilter));

    dump.appendFormat(INDENT3 "UseAveragingTouchFilter: %s\n",

            toString(mParameters.useAveragingTouchFilter));

    dump.appendFormat(INDENT3 "UseJumpyTouchFilter: %s\n",

            toString(mParameters.useJumpyTouchFilter));

}



void TouchInputMapper::configureRawAxes() {
@@ -1349,24 +1383,25 @@ void TouchInputMapper::configureRawAxes() { 
    mRawAxes.orientation.clear();

}



static void logAxisInfo(RawAbsoluteAxisInfo axis, const char* name) {

static void dumpAxisInfo(String8& dump, RawAbsoluteAxisInfo axis, const char* name) {

    if (axis.valid) {

        LOGI(INDENT "Raw %s axis: min=%d, max=%d, flat=%d, fuzz=%d",

        dump.appendFormat(INDENT4 "%s: min=%d, max=%d, flat=%d, fuzz=%d\n",

                name, axis.minValue, axis.maxValue, axis.flat, axis.fuzz);

    } else {

        LOGI(INDENT "Raw %s axis: unknown range", name);

        dump.appendFormat(INDENT4 "%s: unknown range\n", name);

    }

}



void TouchInputMapper::logRawAxes() {

    logAxisInfo(mRawAxes.x, "x");

    logAxisInfo(mRawAxes.y, "y");

    logAxisInfo(mRawAxes.pressure, "pressure");

    logAxisInfo(mRawAxes.touchMajor, "touchMajor");

    logAxisInfo(mRawAxes.touchMinor, "touchMinor");

    logAxisInfo(mRawAxes.toolMajor, "toolMajor");

    logAxisInfo(mRawAxes.toolMinor, "toolMinor");

    logAxisInfo(mRawAxes.orientation, "orientation");

void TouchInputMapper::dumpRawAxes(String8& dump) {

    dump.append(INDENT3 "Raw Axes:\n");

    dumpAxisInfo(dump, mRawAxes.x, "X");

    dumpAxisInfo(dump, mRawAxes.y, "Y");

    dumpAxisInfo(dump, mRawAxes.pressure, "Pressure");

    dumpAxisInfo(dump, mRawAxes.touchMajor, "TouchMajor");

    dumpAxisInfo(dump, mRawAxes.touchMinor, "TouchMinor");

    dumpAxisInfo(dump, mRawAxes.toolMajor, "ToolMajor");

    dumpAxisInfo(dump, mRawAxes.toolMinor, "ToolMinor");

    dumpAxisInfo(dump, mRawAxes.orientation, "Orientation");

}



bool TouchInputMapper::configureSurfaceLocked() {
@@ -1391,10 +1426,8 @@ bool TouchInputMapper::configureSurfaceLocked() { 


    bool sizeChanged = mLocked.surfaceWidth != width || mLocked.surfaceHeight != height;

    if (sizeChanged) {

        LOGI("Device reconfigured (display size changed): id=0x%x, name=%s",

                getDeviceId(), getDeviceName().string());

        LOGI(INDENT "Width: %dpx", width);

        LOGI(INDENT "Height: %dpx", height);

        LOGI("Device reconfigured: id=0x%x, name=%s, display size is now %dx%d",

                getDeviceId(), getDeviceName().string(), width, height);



        mLocked.surfaceWidth = width;

        mLocked.surfaceHeight = height;
@@ -1562,39 +1595,13 @@ bool TouchInputMapper::configureSurfaceLocked() { 
        mLocked.orientedRanges.y.fuzz = orientedYScale;

    }



    if (sizeChanged) {

        logMotionRangesLocked();

    }



    return true;

}



static void logMotionRangeInfo(InputDeviceInfo::MotionRange* range, const char* name) {

    if (range) {

        LOGI(INDENT "Output %s range: min=%f, max=%f, flat=%f, fuzz=%f",

                name, range->min, range->max, range->flat, range->fuzz);

    } else {

        LOGI(INDENT "Output %s range: unsupported", name);

    }

}



void TouchInputMapper::logMotionRangesLocked() {

    logMotionRangeInfo(& mLocked.orientedRanges.x, "x");

    logMotionRangeInfo(& mLocked.orientedRanges.y, "y");

    logMotionRangeInfo(mLocked.orientedRanges.havePressure

            ? & mLocked.orientedRanges.pressure : NULL, "pressure");

    logMotionRangeInfo(mLocked.orientedRanges.haveSize

            ? & mLocked.orientedRanges.size : NULL, "size");

    logMotionRangeInfo(mLocked.orientedRanges.haveTouchArea

            ? & mLocked.orientedRanges.touchMajor : NULL, "touchMajor");

    logMotionRangeInfo(mLocked.orientedRanges.haveTouchArea

            ? & mLocked.orientedRanges.touchMinor : NULL, "touchMinor");

    logMotionRangeInfo(mLocked.orientedRanges.haveToolArea

            ? & mLocked.orientedRanges.toolMajor : NULL, "toolMajor");

    logMotionRangeInfo(mLocked.orientedRanges.haveToolArea

            ? & mLocked.orientedRanges.toolMinor : NULL, "toolMinor");

    logMotionRangeInfo(mLocked.orientedRanges.haveOrientation

            ? & mLocked.orientedRanges.orientation : NULL, "orientation");

void TouchInputMapper::dumpSurfaceLocked(String8& dump) {

    dump.appendFormat(INDENT3 "SurfaceWidth: %dpx\n", mLocked.surfaceWidth);

    dump.appendFormat(INDENT3 "SurfaceHeight: %dpx\n", mLocked.surfaceHeight);

    dump.appendFormat(INDENT3 "SurfaceOrientation: %d\n", mLocked.surfaceOrientation);

}



void TouchInputMapper::configureVirtualKeysLocked() {
@@ -1651,9 +1658,21 @@ void TouchInputMapper::configureVirtualKeysLocked() { 
        virtualKey.hitBottom = (virtualKeyDefinition.centerY + halfHeight)

                * touchScreenHeight / mLocked.surfaceHeight + touchScreenTop;



        LOGI(INDENT "VirtualKey %d: keyCode=%d hitLeft=%d hitRight=%d hitTop=%d hitBottom=%d",

                virtualKey.scanCode, virtualKey.keyCode,

                virtualKey.hitLeft, virtualKey.hitRight, virtualKey.hitTop, virtualKey.hitBottom);

    }

}



void TouchInputMapper::dumpVirtualKeysLocked(String8& dump) {

    if (!mLocked.virtualKeys.isEmpty()) {

        dump.append(INDENT3 "Virtual Keys:\n");



        for (size_t i = 0; i < mLocked.virtualKeys.size(); i++) {

            const VirtualKey& virtualKey = mLocked.virtualKeys.itemAt(i);

            dump.appendFormat(INDENT4 "%d: scanCode=%d, keyCode=%d, "

                    "hitLeft=%d, hitRight=%d, hitTop=%d, hitBottom=%d\n",

                    i, virtualKey.scanCode, virtualKey.keyCode,

                    virtualKey.hitLeft, virtualKey.hitRight,

                    virtualKey.hitTop, virtualKey.hitBottom);

        }

    }

}
@@ -1861,19 +1880,19 @@ void TouchInputMapper::resolveCalibration() { 
    }

}



void TouchInputMapper::logCalibration() {

    LOGI(INDENT "Calibration:");

void TouchInputMapper::dumpCalibration(String8& dump) {

    dump.append(INDENT3 "Calibration:\n");



    // Touch Area

    switch (mCalibration.touchAreaCalibration) {

    case Calibration::TOUCH_AREA_CALIBRATION_NONE:

        LOGI(INDENT INDENT "touch.touchArea.calibration: none");

        dump.append(INDENT4 "touch.touchArea.calibration: none\n");

        break;

    case Calibration::TOUCH_AREA_CALIBRATION_GEOMETRIC:

        LOGI(INDENT INDENT "touch.touchArea.calibration: geometric");

        dump.append(INDENT4 "touch.touchArea.calibration: geometric\n");

        break;

    case Calibration::TOUCH_AREA_CALIBRATION_PRESSURE:

        LOGI(INDENT INDENT "touch.touchArea.calibration: pressure");

        dump.append(INDENT4 "touch.touchArea.calibration: pressure\n");

        break;

    default:

        assert(false);
@@ -1882,40 +1901,43 @@ void TouchInputMapper::logCalibration() { 
    // Tool Area

    switch (mCalibration.toolAreaCalibration) {

    case Calibration::TOOL_AREA_CALIBRATION_NONE:

        LOGI(INDENT INDENT "touch.toolArea.calibration: none");

        dump.append(INDENT4 "touch.toolArea.calibration: none\n");

        break;

    case Calibration::TOOL_AREA_CALIBRATION_GEOMETRIC:

        LOGI(INDENT INDENT "touch.toolArea.calibration: geometric");

        dump.append(INDENT4 "touch.toolArea.calibration: geometric\n");

        break;

    case Calibration::TOOL_AREA_CALIBRATION_LINEAR:

        LOGI(INDENT INDENT "touch.toolArea.calibration: linear");

        dump.append(INDENT4 "touch.toolArea.calibration: linear\n");

        break;

    default:

        assert(false);

    }



    if (mCalibration.haveToolAreaLinearScale) {

        LOGI(INDENT INDENT "touch.toolArea.linearScale: %f", mCalibration.toolAreaLinearScale);

        dump.appendFormat(INDENT4 "touch.toolArea.linearScale: %0.3f\n",

                mCalibration.toolAreaLinearScale);

    }



    if (mCalibration.haveToolAreaLinearBias) {

        LOGI(INDENT INDENT "touch.toolArea.linearBias: %f", mCalibration.toolAreaLinearBias);

        dump.appendFormat(INDENT4 "touch.toolArea.linearBias: %0.3f\n",

                mCalibration.toolAreaLinearBias);

    }



    if (mCalibration.haveToolAreaIsSummed) {

        LOGI(INDENT INDENT "touch.toolArea.isSummed: %d", mCalibration.toolAreaIsSummed);

        dump.appendFormat(INDENT4 "touch.toolArea.isSummed: %d\n",

                mCalibration.toolAreaIsSummed);

    }



    // Pressure

    switch (mCalibration.pressureCalibration) {

    case Calibration::PRESSURE_CALIBRATION_NONE:

        LOGI(INDENT INDENT "touch.pressure.calibration: none");

        dump.append(INDENT4 "touch.pressure.calibration: none\n");

        break;

    case Calibration::PRESSURE_CALIBRATION_PHYSICAL:

        LOGI(INDENT INDENT "touch.pressure.calibration: physical");

        dump.append(INDENT4 "touch.pressure.calibration: physical\n");

        break;

    case Calibration::PRESSURE_CALIBRATION_AMPLITUDE:

        LOGI(INDENT INDENT "touch.pressure.calibration: amplitude");

        dump.append(INDENT4 "touch.pressure.calibration: amplitude\n");

        break;

    default:

        assert(false);
@@ -1923,10 +1945,10 @@ void TouchInputMapper::logCalibration() { 


    switch (mCalibration.pressureSource) {

    case Calibration::PRESSURE_SOURCE_PRESSURE:

        LOGI(INDENT INDENT "touch.pressure.source: pressure");

        dump.append(INDENT4 "touch.pressure.source: pressure\n");

        break;

    case Calibration::PRESSURE_SOURCE_TOUCH:

        LOGI(INDENT INDENT "touch.pressure.source: touch");

        dump.append(INDENT4 "touch.pressure.source: touch\n");

        break;

    case Calibration::PRESSURE_SOURCE_DEFAULT:

        break;
@@ -1935,16 +1957,17 @@ void TouchInputMapper::logCalibration() { 
    }



    if (mCalibration.havePressureScale) {

        LOGI(INDENT INDENT "touch.pressure.scale: %f", mCalibration.pressureScale);

        dump.appendFormat(INDENT4 "touch.pressure.scale: %0.3f\n",

                mCalibration.pressureScale);

    }



    // Size

    switch (mCalibration.sizeCalibration) {

    case Calibration::SIZE_CALIBRATION_NONE:

        LOGI(INDENT INDENT "touch.size.calibration: none");

        dump.append(INDENT4 "touch.size.calibration: none\n");

        break;

    case Calibration::SIZE_CALIBRATION_NORMALIZED:

        LOGI(INDENT INDENT "touch.size.calibration: normalized");

        dump.append(INDENT4 "touch.size.calibration: normalized\n");

        break;

    default:

        assert(false);
@@ -1953,10 +1976,10 @@ void TouchInputMapper::logCalibration() { 
    // Orientation

    switch (mCalibration.orientationCalibration) {

    case Calibration::ORIENTATION_CALIBRATION_NONE:

        LOGI(INDENT INDENT "touch.orientation.calibration: none");

        dump.append(INDENT4 "touch.orientation.calibration: none\n");

        break;

    case Calibration::ORIENTATION_CALIBRATION_INTERPOLATED:

        LOGI(INDENT INDENT "touch.orientation.calibration: interpolated");

        dump.append(INDENT4 "touch.orientation.calibration: interpolated\n");

        break;

    default:

        assert(false);