android触摸震动原理

最新推荐文章于 2024-01-15 16:00:29 发布
最新推荐文章于 2024-01-15 16:00:29 发布
阅读量4.6k 收藏 2
点赞数
分类专栏： android开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A15262901392/article/details/62222203
版权
android触摸震动原理
作者： qw15262901392@gmail.com
http://bbs.elecfans.com/jishu_518936_1_1.html(Timed_gpio.c、Timed_gpio.h、Timed_output.c、Timed_output.h)
Z:\16.16.2_X5542DK\idh.code\frameworks\base\services\core\java\com\android\server\policy\PhoneWindowManager


事件：点击Menu Home Back 键触摸震动：
开关触摸震动功能：
观察log
haptic_feedback_enabled
adb shell settings get system haptic_feedback_enabled --- HAPTIC_FEEDBACK_ENABLED



1.手机触摸：参考android输入事件
InputManagerService也就是InputDispatcher与应用程序通信是靠looper
InputReader从设备文件中读取的是RawEvent，在交给InputDispatcher进行分发之前，它需要先把RawEvent进行转化分类，拆分成KeyEvent、MotionEvent、TrackEvent各种类型等。
InputDispatcher获得按键事件后，根据当前设备的状况来优先消化事件（该过程交由PhoneWindowManager.java来处理）；最后，剩余事件分发给ViewRoot；ViewRoot再分发给IME输入法或View、Activity

2.系统震动：android震动应用层

3.马达震动的硬件设计

android输入事件
作者： qw15262901392@gmail.com
frameworks\base\services\core\java\com\android\server\policy\PhoneWindowManager.java
@Override
    public boolean performHapticFeedbackLw(WindowState win, int effectId, boolean always) {
        if (!mVibrator.hasVibrator()) {
            return false;
        }
        final boolean hapticsDisabled = Settings.System.getIntForUser(mContext.getContentResolver(),
                Settings.System.HAPTIC_FEEDBACK_ENABLED, 0, UserHandle.USER_CURRENT) == 0;
        if (hapticsDisabled && !always) {
            return false;
        }
        long[] pattern = null;
        switch (effectId) {
            case HapticFeedbackConstants.LONG_PRESS:
                pattern = mLongPressVibePattern;
                break;
            case HapticFeedbackConstants.VIRTUAL_KEY:
                pattern = mVirtualKeyVibePattern;
                break;
            case HapticFeedbackConstants.KEYBOARD_TAP:
                pattern = mKeyboardTapVibePattern;
                break;
            case HapticFeedbackConstants.CLOCK_TICK:
                pattern = mClockTickVibePattern;
                break;
            case HapticFeedbackConstants.CALENDAR_DATE:
                pattern = mCalendarDateVibePattern;
                break;
            case HapticFeedbackConstants.SAFE_MODE_DISABLED:
                pattern = mSafeModeDisabledVibePattern;
                break;
            case HapticFeedbackConstants.SAFE_MODE_ENABLED:
                pattern = mSafeModeEnabledVibePattern;
                break;
            case HapticFeedbackConstants.CONTEXT_CLICK:
                pattern = mContextClickVibePattern;
                break;
            default:
                return false;
        }
        int owningUid;
        String owningPackage;
        if (win != null) {
            owningUid = win.getOwningUid();
            owningPackage = win.getOwningPackage();
        } else {
            owningUid = android.os.Process.myUid();
            owningPackage = mContext.getOpPackageName();
        }
        if (pattern.length == 1) {
            // One-shot vibration
            mVibrator.vibrate(owningUid, owningPackage, pattern[0], VIBRATION_ATTRIBUTES);
        } else {
            // Pattern vibration
            mVibrator.vibrate(owningUid, owningPackage, pattern, -1, VIBRATION_ATTRIBUTES);
        }
        return true;
    }


涉及到android输入事件  参考：


com_android_server_input_InputManagerService.cpp
void NativeInputManager::interceptKeyBeforeQueueing(const KeyEvent* keyEvent,
        uint32_t& policyFlags) {
    // Policy:
    // - Ignore untrusted events and pass them along.
    // - Ask the window manager what to do with normal events and trusted injected events.
    // - For normal events wake and brighten the screen if currently off or dim.
    bool interactive = mInteractive.load();
    if (interactive) {
        policyFlags |= POLICY_FLAG_INTERACTIVE;
    }
    if ((policyFlags & POLICY_FLAG_TRUSTED)) {
        nsecs_t when = keyEvent->getEventTime();
        JNIEnv* env = jniEnv();
        jobject keyEventObj = android_view_KeyEvent_fromNative(env, keyEvent);
        jint wmActions;
        if (keyEventObj) {
            wmActions = env->CallIntMethod(mServiceObj,
                    gServiceClassInfo.interceptKeyBeforeQueueing,
                    keyEventObj, policyFlags);
            if (checkAndClearExceptionFromCallback(env, "interceptKeyBeforeQueueing")) {
                wmActions = 0;
            }
            android_view_KeyEvent_recycle(env, keyEventObj);
            env->DeleteLocalRef(keyEventObj);
        } else {
            ALOGE("Failed to obtain key event object for interceptKeyBeforeQueueing.");
            wmActions = 0;
        }

        handleInterceptActions(wmActions, when, /*byref*/ policyFlags);
    } else {
        if (interactive) {
            policyFlags |= POLICY_FLAG_PASS_TO_USER;
        }
    }
}

C++层打Log：
ALOGE("MXQ------------------------------------------------");


#include <utils/CallStack.h>
android::CallStack cs("MXQ---");


EventHub.cpp主要用来读取设备文件中的RawEvent，而InputReader.cpp和InputDispatcher.cpp算是它们之间的对接层

InputDispatcher.cpp

ALOGD不能输出信息  和KeyCode有关

WindowManagerService通过InputManager提供的接口开启一个线程驱动InputReader不断地从/dev/input/目录下面的设备文件读取事件，然后通过InputDispatcher分发给连接到WindowManagerService服务的客户端


android 震动

作者： qw15262901392@gmail.com

应用层

Vibrator：
 它是马达服务开放给应用层的调用类。理论上讲，我们完全可以通过aidl直接调用马达服务，而不需要Vibrator.java类。但是！既然它存在，就肯定有它的理由。事实的确如此，Google之所以这么做。有以下几个原因：
           第一，提供统一而且方便的服务调用方式。这里的“统一”，是指和所有其它的系统服务一样，我们调用服务时，需先通过getSystemService()获取服务，然后再调用服务的函数接口。这里的“方便”，是指若我们直接通过aidl调用，操作比较繁琐(若你用过aidl就会知道，需要先实现ServiceConnection接口以获取IBinder对象，然后再通过IBinder对象调用aidl的接口)； 而Vibrator.java封装之后的接口，将许多细节都隐藏了，非常便于应用者调用！
          第二，基于安全的考虑。Vibrator.java封装隐藏了许多细节，而这些都是应用开发者不必要知道的。
          第三，Vibrator是抽象类。它便于我们支持不同类型的马达：包括“将马达直接映射到文件”以及“将马达注册到输入子系统”中。

SystemVibrator
它是Vibrator.java的子类，实现了马达的服务接口
    @Override
    public void vibrate(int uid, String opPkg, long[] pattern, int repeat,
            AudioAttributes attributes) {
        if (mService == null) {
            Log.w(TAG, "Failed to vibrate; no vibrator service.");
            return;
        }
        // catch this here because the server will do nothing.  pattern may
        // not be null, let that be checked, because the server will drop it
        // anyway
        if (repeat < pattern.length) {
            try {
                  mService.vibratePattern(uid, opPkg, pattern, repeat, usageForAttributes(attributes),
                        mToken);
            } catch (RemoteException e) {
                Log.w(TAG, "Failed to vibrate.", e);
            }
        } else {
            throw new ArrayIndexOutOfBoundsException();
        }
    }

public SystemVibrator() {
        mService = IVibratorService.Stub.asInterface(
                ServiceManager.getService("vibrator"));
    }

public static IBinder getService(String name) {
        try {
            IBinder service = sCache.get(name);
            if (service != null) {
                return service;
            } else {
                return getIServiceManager().getService(name);
            }
        } catch (RemoteException e) {
            Log.e(TAG, "error in getService", e);
        }
        return null;
    }
    public static void addService(String name, IBinder service) {
        try {
            getIServiceManager().addService(name, service, false);
        } catch (RemoteException e) {
            Log.e(TAG, "error in addService", e);
        }
    }

SystemServer
它是系统服务，作用是启动、管理系统服务，包括“马达服务、Wifi服务、Activity管理服务”等
 
SystemServer是通过Zygote启动的，而Zygote又是在init中启动的，init则是kernel加载完毕之后启动的第一个进程。在这里，我们只需要知道“SystemServer是用来启动/管理马达服务即可
-->寻找addService
            Slog.i(TAG, "Vibrator Service");
            vibrator = new VibratorService(context);
            ServiceManager.addService("vibrator", vibrator);

VibratorService
它是马达服务对应的aidl接口的实现程序。它实现IVibratorService.aidl的接口，从而实现马达服务；它的函数接口，是通过调用JNI层对应的马达控制函数来实现的。
 @Override // Binder call
    public void vibratePattern(int uid, String packageName, long[] pattern, int repeat,
            int usageHint, IBinder token) {
        if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.VIBRATE)
                != PackageManager.PERMISSION_GRANTED) {
            throw new SecurityException("Requires VIBRATE permission");
        }
        verifyIncomingUid(uid);
        // so wakelock calls will succeed
        long identity = Binder.clearCallingIdentity();
        try {
            if (DEBUG) {
                String s = "";
                int N = pattern.length;
                for (int i=0; i<N; i++) {
                    s += " " + pattern[i];
                }
                Slog.d(TAG, "Vibrating with pattern:" + s);
            }

            // we're running in the server so we can't fail
            if (pattern == null || pattern.length == 0
                    || isAll0(pattern)
                    || repeat >= pattern.length || token == null) {
                return;
            }

            Vibration vib = new Vibration(token, pattern, repeat, usageHint, uid, packageName);
            try {
                token.linkToDeath(vib, 0);
            } catch (RemoteException e) {
                return;
            }

            synchronized (mVibrations) {
                removeVibrationLocked(token);
                doCancelVibrateLocked();
                if (repeat >= 0) {
                    mVibrations.addFirst(vib);
                    startNextVibrationLocked();
                } else {
                    // A negative repeat means that this pattern is not meant
                    // to repeat. Treat it like a simple vibration.
                    mCurrentVibration = vib;
                    startVibrationLocked(vib);
                }
                addToPreviousVibrationsLocked(vib);
            }
        }
        finally {
            Binder.restoreCallingIdentity(identity);
        }
    }

// Lock held on mVibrations
    private void startVibrationLocked(final Vibration vib) {
        try {
            if (mLowPowerMode
                    && vib.mUsageHint != AudioAttributes.USAGE_NOTIFICATION_RINGTONE) {
                return;
            }

            int mode = mAppOpsService.checkAudioOperation(AppOpsManager.OP_VIBRATE,
                    vib.mUsageHint, vib.mUid, vib.mOpPkg);
            if (mode == AppOpsManager.MODE_ALLOWED) {
                mode = mAppOpsService.startOperation(AppOpsManager.getToken(mAppOpsService),
                    AppOpsManager.OP_VIBRATE, vib.mUid, vib.mOpPkg);
            }
            if (mode != AppOpsManager.MODE_ALLOWED) {
                if (mode == AppOpsManager.MODE_ERRORED) {
                    Slog.w(TAG, "Would be an error: vibrate from uid " + vib.mUid);
                }
                mH.post(mVibrationRunnable);
                return;
            }
        } catch (RemoteException e) {
        }
        if (vib.mTimeout != 0) {
            doVibratorOn(vib.mTimeout, vib.mUid, vib.mUsageHint);
            mH.postDelayed(mVibrationRunnable, vib.mTimeout);
        } else {
            // mThread better be null here. doCancelVibrate should always be
            // called before startNextVibrationLocked or startVibrationLocked.
            mThread = new VibrateThread(vib);
            mThread.start();
        }
    }

      public void run() {
            Process.setThreadPriority(Process.THREAD_PRIORITY_URGENT_DISPLAY);
            synchronized (this) {
                final long[] pattern = mVibration.mPattern;
                final int len = pattern.length;
                final int repeat = mVibration.mRepeat;
                final int uid = mVibration.mUid;
                final int usageHint = mVibration.mUsageHint;
                int index = 0;
                long duration = 0;

                while (!mDone) {
                    // add off-time duration to any accumulated on-time duration
                    if (index < len) {
                        duration += pattern[index++];
                    }

                    // sleep until it is time to start the vibrator
                    delay(duration);
                    if (mDone) {
                        break;
                    }

                    if (index < len) {
                        // read on-time duration and start the vibrator
                        // duration is saved for delay() at top of loop
                        duration = pattern[index++];
                        if (duration > 0) {
                            VibratorService.this.doVibratorOn(duration, uid, usageHint);
                        }
                    } else {
                        if (repeat < 0) {
                            break;
                        } else {
                            index = repeat;
                            duration = 0;
                        }
                    }
                }
                mWakeLock.release();
            }
            synchronized (mVibrations) {
                if (mThread == this) {
                    mThread = null;
                }
                if (!mDone) {
                    // If this vibration finished naturally, start the next
                    // vibration.
                    unlinkVibration(mVibration);
                    startNextVibrationLocked();
                }
            }
        }
    }

private void doVibratorOn(long millis, int uid, int usageHint) {
        synchronized (mInputDeviceVibrators) {
            if (DEBUG) {
                Slog.d(TAG, "Turning vibrator on for " + millis + " ms.");
            }
            try {
                mBatteryStatsService.noteVibratorOn(uid, millis);
                mCurVibUid = uid;
            } catch (RemoteException e) {
            }
            final int vibratorCount = mInputDeviceVibrators.size();
            if (vibratorCount != 0) {
                final AudioAttributes attributes = new AudioAttributes.Builder().setUsage(usageHint)
                        .build();
                for (int i = 0; i < vibratorCount; i++) {
                    mInputDeviceVibrators.get(i).vibrate(millis, attributes);
                }
            } else {
                vibratorOn(millis);
            }
        }
    }


马达震动的硬件设计

来源网址： http://www.cnblogs.com/skywang12345/p/3404808.html
作者： qw15262901392@gmail.com
概述：
马达--电动机
我们进行Linux Driver开发的目的，就是将硬件设备映射成一个文件；然后，我们可以通过操作文件，来操作对应的硬件设备。
马达的震动原理：通电
如何给马达通电：
三星A8的CPU 马达的   GPIO是GPH3_3

芯片手册（   Datasheet）：
GPH3_3

驱动层：
int vibrator_exists()
{
    int fd;

#ifdef QEMU_HARDWARE
    if (qemu_check()) {
        return 1;
    }
#endif

    fd =   open(THE_DEVICE, O_RDWR);//当我们在用户空间调用open之后，会产生一个软中断，然后通过系统调用进入内核空间。通过系统调用号，我们就可以跳转到该中断例程的入口地址
 ALOGI("-------------------------:%d", fd);
    if(fd < 0)
        return 0;
    close(fd);
    return 1;
}


参考：
对于enable文件，“写”表示使能指定的时间，“读”表示获取剩余时间
echo "10000" > /sys/class/timed_output/vibrator/enable
cat /sys/class/timed_output/vibrator/enable

自下而上，Android的振动器系统分成了以下部分。
（1）驱动程序：特定硬件平台振动器的驱动程序，通常基于Android的Timed Output驱动框架实现
/kernel/drivers/staging/android/timed_output.h
/kernel/drivers/staging/android/timed_output.c
（2）硬件抽象层 :
光系统硬件抽象层接口路径为：hardware/libhardware_legacy/include/hardware_legacy/ vibrator.h
振动器系统的硬件抽象层在Android中已经具有默认实现，代码路径：
hardware/libhardware_legacy/vibrator/vibrator.c
振动器的硬件抽象层通常并不需要重新实现，是libhardware_legacy.so的一部分。
（3）JNI部分
代码路径：frameworks/base/services/jni/com_android_server_VibratorService.cpp
这个类是振动器的JNI部分，通过调用硬件抽象层向上层提供接口。
（4）Java部分
代码路径：
frameworks/base/services/java/com/android/server/VibratorService.java
frameworks/base/core/java/android/os/Vibrator.java
VibratorService.java通过调用，VibratorService JNI来实现com.android.server包中的VibratorService类。这个类不是平台的API，被Android系统Java框架中的一小部分调用。
Vibrator.java文件实现了android.os包中的Vibrator类，这是向Java层提供的API。




马达震动的驱动（内核层面）设计
来源网址： http://www.cnblogs.com/skywang12345/p/3404808.html
作者： qw15262901392@gmail.com

timed_output.c（对寄存器操作的）
static ssize_t enable_show(struct device *dev, struct device_attribute *attr,
        char *buf)
{
    struct timed_output_dev *tdev = dev_get_drvdata(dev);
    int remaining = tdev->get_time(tdev);

    return sprintf(buf, "%d\n", remaining);
}

static ssize_t enable_store(
        struct device *dev, struct device_attribute *attr,
        const char *buf, size_t size)
{
    struct timed_output_dev *tdev = dev_get_drvdata(dev);
    int value;

    if (sscanf(buf, "%d", &value) != 1)
        return -EINVAL;

    tdev->enable(tdev, value);

    return size;
}
通过devfs文件系统访问方法，这里把设备的寄存器val看成是设备的一个属性，通过读写这个属性来对设备进行访问，主要是实现hello_val_show和hello_val_store两个方法（老罗）

（ General Purpose Input Output （通用输入/输出））


QinQin_92
关注
专栏目录
Android 解决USB TP驱动中触摸卡顿和防抖动问题
我其实什么都不会
10-20 475
在本文中，我将探讨如何在Android 内核驱动中优化USB TP并解决这一触摸事件的防抖动问题。
android 触屏的震动响应接口调用方法
09-05
android 相关开发过程中，经常会使用到触屏的震动响应接口，为此本文列出以下方法，想要了解的朋友可以参考下
Android11 view的触摸振动流程（HAPTIC_FEEDBACK_ENABLED）
最新发布
qq_36975610的博客
01-15 660
Android11 view的触摸振动流程
android触屏震动以及震动强度修改
初心(linux,python,php,photoshop)
09-26 2408
PhoneWindowManager.java： 在interceptKeyBeforeQueueing函数中 performHapticFeedbackLw(null, HapticFeedbackConstants.VIRTUAL_KEY, false); 这里把false改为true。 [code="java"] public boolean performHapticFe...
android 点击震动,Android应用中实现点击按钮震动
weixin_32316643的博客
05-26 536
项目中需要实现点击应用中的按钮，有震动效果。震动效果可以在设置中进行关闭。具体实现如下。编写震动帮助类：VibrateHelp.javaimport android.content.Context;import android.os.Vibrator;/*** 震动帮助类* androidManifest.xml中加入 以下权限**/public class VibrateHelp {privat...
老生常谈Android HapticFeedback(震动反馈)
08-30
在Android的设置中，可以在“声音和震动”选项中调整触摸时的震动强度。对于开发者而言，通常无需关心这个过程，只需调用`performHapticFeedback`即可。 总的来说，Android的HapticFeedback为用户提供了一种直观且...
android应用源码手机震动.zip
12-05
下面我们将深入探讨Android中手机震动的实现原理及相关知识点。 1. **Vibrator服务**： Android系统提供了一个名为`Vibrator`的服务，允许应用程序控制设备的震动器。开发者可以使用`Vibrator`类来实现震动效果。...
android 手机震动效果
06-27
简单的时间手机震动的效果.比较实用的demo
android打开触摸时振动,解决 Android 5.1 触摸屏上的多任务按键没有震动反馈的 bug...
weixin_39915204的博客
05-26 457
解决方案：diff --git a/frameworks/base/policy/src/com/android/internal/policy/impl/PhoneWindowManager.java b/frameworks/base/policy/src/com/android/internal/policy/impl/PhoneWindowManager.javaindex d25051e...
android5.1.1 触摸震动,基于android5.1无显示触摸系统的系统镜像裁剪
weixin_35316287的博客
05-26 222
http://blog.csdn.net/qwertyuiop159158/article/details/50053551思路：1: 编译后查看out\target\product\product\system文件夹的内容,从这个文件夹入手,裁剪不必要的服务,库文件,apk,等等.2: 了解真个编译系统,从编译过程入手,看隐含的可裁剪项,过程和思路很重要具体裁剪内容:1: build/ta...
Android学习之手机震动
悟已往之不谏 知来者之可追
08-11 643
1、定义变量 Vibrator vibrator; 2、获取震动服务的句柄 vibrator=(Vibrator)getSystemService(Service.VIBRATOR_SERVICE);//震动 3、注册权限 &amp;lt;uses-permission android:name=&quot;android.permission.VIBRATE&quot;/&amp;gt; 4、开启震动 ...
设置效果android滑动解锁的震动效果
weixin_34224941的博客
05-06 164
每日一贴,今天的内容关键字为设置效果            在4.0的圆环滑动锁解中，我们点击下去的时候会有震撼效果，因为这个间空设置的震撼效果没有绑定设置中设置的触摸振动关开来取消振动效果，     所以如果我们要需根据设置中的触摸震撼关开来开启和取消滑动锁解的震撼效果，就要需做以下修改了。           在LockScreen.java类中的LockScreen方法中的    ...
Android 7.1 点按震动,Android 7.1.1 之实现 3D Touch
weixin_30780735的博客
05-28 263
Shortcut概念Shortcut 是Android-25(Android 7.1)新增的一项相似iOS的 3D Touch 功能的快捷方式组件。可是有着不同的表现形式。由于Android在硬件上不支持触摸压力感应，所以表现形式为长按，而iOS须用力长按。首先。来个效果图 在 Launcher 或 应用程序列表 里面。长按应用图标，弹出一个快捷方式列表。 而且，能够把单个快捷方式拖动出...
Android修改触摸按键震动强弱
热门推荐
05-25 1万+
为了加强返回键触感效果，查了一些资料。修改代码位置：     frameworks/base/core/res/res/values/config.xml     可修改以下内容：                   0             // 暂停时间         10        //震动时间         20         //暂停时间         3
Android开发教程：手机震动控制浅析
于大大大洋
04-03 2889
Android系统中Vibrator对象负责对手机震动的处理，具体的实现方法：  1.获取振动器Vibrator的实例：  Vibrator vibrator = (Vibrator) getSystemService(VIBRATOR_SERVICE);  getSystemService(VIBRATOR_SERVICE)：获得 一个震动的服务 2.调用vibrate方法来
android 触摸时震动,android触屏震动以及震动强度批改
weixin_39637363的博客
05-26 932
android触屏震动以及震动强度修改PhoneWindowManager.java：在interceptKeyBeforeQueueing函数中performHapticFeedbackLw(null, HapticFeedbackConstants.VIRTUAL_KEY, false);这里把false改为true。public boolean performHapticFeedbackLw...
android 点击震动,Android 实现为点击事件添加震动效果
weixin_39763683的博客
05-26 872
Android 点击Button 实现震动效果教程Overview在Android 的点击效果中，遇到震动效果的还是很多的。接下来就让我们看一下如何实现震动效果。所需要的权限如果我们在开发中需要使用到我们的震动，那么我们就需要申请一下权限：这样我们的权限就申请好了。我们震动效果的帮助类创建一个名为VibrateHelp的点击震动的帮助类。然后看一下如何使用他的把：public class Vibr...
Android 10.0 framework 默认开启振动
安卓兼职framework和app工程师的博客
04-22 1115
在系统settings 的声音菜单下 有一个开启震动的 功能开关，默认是关闭的，由于项目的需要要求 开启震动功能，所以就要看源码震动开关是怎么打开的 Android 开启振动主要运用了 Vibrator（振动器），系统中有一个 Vibrator 抽象类，我们可以通过获取 Vibrator实例调用里面的方法来完成振动功能。 Vibrator vibrator = (Vibrator) getSystemServic(Service.VIBRATOR_SERVICE); vibrator.vibrate(100
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值