Android之手势识别

最新推荐文章于 2021-01-20 14:07:21 发布
最新推荐文章于 2021-01-20 14:07:21 发布
阅读量1k 收藏 1
点赞数
分类专栏： Android sample
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/I_do_can/article/details/53185654
版权

本文所用的例子的是Google提供，关于手势识别

源码：https://github.com/CL-window/Gestures

down: http://download.csdn.net/detail/i_do_can/9684516

是一个测试版本，适合开发阶段录入手势


手势识别，主要是用的Google的GestureLibrary库

第一步，加载手势库，(没有就新建一个空白的)

new File(Environment.getExternalStorageDirectory(), "gestures");
    GestureLibraries.fromFile(File/filePath); // 从文件 适合开发时
    GestureLibraries.fromRawResource(this,R.raw.gestures);// raw文件

第二步，手势的画板 
GestureOverlayView
    <!--
    GestureOverlayView：一种用于手势输入的透明覆盖层，可覆盖在其他控件的上方，也可包含其他控件。
    android:gestureStrokeType 定义笔画（定义为手势）的类型
    android:gestureStrokeWidth 画手势时，笔划的宽度
    -->
    <android.gesture.GestureOverlayView
        android:id="@+id/gestures_overlay"
        android:layout_width="match_parent"
        android:layout_height="0dip"
        android:layout_weight="1.0"
        android:gestureColor="@color/gesture_color"
        android:gestureStrokeWidth="10"
        android:gestureStrokeType="multiple" />

第三步，手势监听
OnGesturePerformedListener监听器监听一种手势(一笔画完)
识别手势 
ArrayList predictions = GestureBuilderActivity.getStore().recognize(gesture);
    if (predictions.size() > 0) {
        //拿到相似度最高的对象
        Prediction prediction = (Prediction) predictions.get(0);
        Log.i("slack","prediction.score : "+ prediction.score);
        // We want at least some confidence in the result 大于2，基本相似
        if (prediction.score > 2.0) {
            // Show the spell
            Toast.makeText(CreateGestureActivity.this, prediction.name, Toast.LENGTH_SHORT).show();
        }
    }

第四步，保存手势
GestureLibrary.addGesture(name, Gesture);
GestureLibrary.save();

导出SD卡里的gestures文件
adb pull sdcard/gestures



新增手势界面

import java.util.ArrayList;

import android.app.Activity;
import android.gesture.Gesture;
import android.gesture.GestureLibrary;
import android.gesture.GestureOverlayView;
import android.gesture.Prediction;
import android.os.Bundle;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;
import android.widget.TextView;
import android.widget.Toast;

public class CreateGestureActivity extends Activity {
    private static final float LENGTH_THRESHOLD = 120.0f;

    private Gesture mGesture;
    private View mDoneButton;

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

        setContentView(R.layout.create_gesture);

        mDoneButton = findViewById(R.id.done);

        GestureOverlayView overlay = (GestureOverlayView) findViewById(R.id.gestures_overlay);
        overlay.addOnGestureListener(new GesturesProcessor());
        overlay.addOnGesturePerformedListener(new GesturePerformedListener());

        /*手势绘制完成后淡出屏幕的时间间隔，即绘制完手指离开屏幕后相隔多长时间手势从屏幕上消失；
         * 可以理解为手势绘制完成手指离开屏幕后到调用onGesturePerformed的时间间隔
         * 默认值为420毫秒，这里设置为0.5秒
         */
        overlay.setFadeOffset(500);

    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);

        if (mGesture != null) {
            outState.putParcelable("gesture", mGesture);
        }
    }

    @Override
    protected void onRestoreInstanceState(Bundle savedInstanceState) {
        super.onRestoreInstanceState(savedInstanceState);

        mGesture = savedInstanceState.getParcelable("gesture");
        if (mGesture != null) {
            final GestureOverlayView overlay =
                    (GestureOverlayView) findViewById(R.id.gestures_overlay);
            overlay.post(new Runnable() {
                public void run() {
                    overlay.setGesture(mGesture);
                }
            });

            mDoneButton.setEnabled(true);
        }
    }

    @SuppressWarnings({"UnusedDeclaration"})
    public void addGesture(View v) {
        if (mGesture != null) {
            final TextView input = (TextView) findViewById(R.id.gesture_name);
            final CharSequence name = input.getText();
            if (name.length() == 0) {
                input.setError(getString(R.string.error_missing_name));
                return;
            }

            final GestureLibrary store = GestureBuilderActivity.getStore();
            store.addGesture(name.toString(), mGesture);
            store.save();

            setResult(RESULT_OK);

//            final String path = new File(Environment.getExternalStorageDirectory(),
//                    "gestures").getAbsolutePath();
//            Toast.makeText(this, getString(R.string.save_success, path), Toast.LENGTH_LONG).show();
        } else {
            setResult(RESULT_CANCELED);
        }

        finish();

    }

    @SuppressWarnings({"UnusedDeclaration"})
    public void cancelGesture(View v) {
        setResult(RESULT_CANCELED);
        finish();
    }

    private class GesturesProcessor implements GestureOverlayView.OnGestureListener {
        public void onGestureStarted(GestureOverlayView overlay, MotionEvent event) {
//            Log.i("slack","onGestureStarted...");
            mDoneButton.setEnabled(false);
            mGesture = null;
        }

        public void onGesture(GestureOverlayView overlay, MotionEvent event) {
//            Log.i("slack","onGesture...");
        }

        public void onGestureEnded(GestureOverlayView overlay, MotionEvent event) {
            Log.i("slack","onGestureEnded...");
            mGesture = overlay.getGesture();
            if (mGesture.getLength() < LENGTH_THRESHOLD) {
                overlay.clear(false);
            }
            mDoneButton.setEnabled(true);
        }

        public void onGestureCancelled(GestureOverlayView overlay, MotionEvent event) {
            Log.i("slack","onGestureCancelled...");
        }
    }

    //OnGesturePerformedListener监听器监听一种手势(一笔画完)
    class GesturePerformedListener implements GestureOverlayView.OnGesturePerformedListener{

        @Override
        public void onGesturePerformed(GestureOverlayView overlay, Gesture gesture) {
            Log.i("slack","onGesturePerformed...");
            mGesture = gesture;
            if (mGesture.getLength() < LENGTH_THRESHOLD) {
                overlay.clear(false);
            }
            mDoneButton.setEnabled(true);
            // 识别手势 Prediction是一个相似度对象,集合中的相似度是从高到低进行排列
            ArrayList predictions = GestureBuilderActivity.getStore().recognize(gesture);

            // We want at least one prediction
            if (predictions.size() > 0) {
                //拿到相似度最高的对象
                Prediction prediction = (Prediction) predictions.get(0);
                Log.i("slack","prediction.score : "+ prediction.score);
                // We want at least some confidence in the result 大于2，基本相似
                if (prediction.score > 2.0) {
                    // Show the spell
                    Toast.makeText(CreateGestureActivity.this, prediction.name, Toast.LENGTH_SHORT).show();
                }
            }
        }
    }
}


手势list界面

import android.Manifest;
import android.app.Dialog;
import android.app.AlertDialog;
import android.app.ListActivity;
import android.content.pm.PackageManager;
import android.os.Build;
import android.os.Bundle;
import android.os.AsyncTask;
import android.os.Environment;
import android.support.v4.app.ActivityCompat;
import android.util.Log;
import android.view.View;
import android.view.ContextMenu;
import android.view.MenuItem;
import android.view.LayoutInflater;
import android.view.ViewGroup;
import android.gesture.GestureLibrary;
import android.gesture.Gesture;
import android.gesture.GestureLibraries;
import android.widget.TextView;
import android.widget.EditText;
import android.widget.AdapterView;
import android.widget.Toast;
import android.widget.ArrayAdapter;
import android.content.DialogInterface;
import android.content.Context;
import android.content.Intent;
import android.content.res.Resources;
import android.text.TextUtils;
import android.graphics.Bitmap;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.BitmapDrawable;

import java.io.IOException;
import java.security.Permission;
import java.util.Map;
import java.util.Collections;
import java.util.HashMap;
import java.util.Comparator;
import java.util.Set;
import java.io.File;

public class GestureBuilderActivity extends ListActivity {

    private final int REQ_PERMISSION_WRITE_STORAGE = 0x10;

    private static final int STATUS_SUCCESS = 0;
    private static final int STATUS_CANCELLED = 1;
    private static final int STATUS_NO_STORAGE = 2;
    private static final int STATUS_NOT_LOADED = 3;

    private static final int MENU_ID_RENAME = 1;
    private static final int MENU_ID_REMOVE = 2;

    private static final int DIALOG_RENAME_GESTURE = 1;

    private static final int REQUEST_NEW_GESTURE = 1;

    // Type: long (id)
    private static final String GESTURES_INFO_ID = "gestures.info_id";

    private final File mStoreFile = new File(Environment.getExternalStorageDirectory(), "gestures");

    private final Comparator<NamedGesture> mSorter = new Comparator<NamedGesture>() {
        public int compare(NamedGesture object1, NamedGesture object2) {
            return object1.name.compareTo(object2.name);
        }
    };

    private static GestureLibrary sStore;

    private GesturesAdapter mAdapter;
    private GesturesLoadTask mTask;
    private TextView mEmpty;

    private Dialog mRenameDialog;
    private EditText mInput;
    private NamedGesture mCurrentRenameGesture;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if( Build.VERSION.SDK_INT >= Build.VERSION_CODES.M &&
                ActivityCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED){
            ActivityCompat.requestPermissions(this,new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},REQ_PERMISSION_WRITE_STORAGE);
        }else {
            withPermission();
        }

        setContentView(R.layout.gestures_list);

        mAdapter = new GesturesAdapter(this);
        setListAdapter(mAdapter);

        initGestures();

        mEmpty = (TextView) findViewById(android.R.id.empty);
        loadGestures();

        registerForContextMenu(getListView());
    }

    private void initGestures() {
        sStore = GestureLibraries.fromFile(mStoreFile);
//        sStore = GestureLibraries.fromRawResource(this,R.raw.gestures);
    }

    static GestureLibrary getStore() {
        return sStore;
    }

    @SuppressWarnings({"UnusedDeclaration"})
    public void reloadGestures(View v) {
        loadGestures();
    }

    @SuppressWarnings({"UnusedDeclaration"})
    public void addGesture(View v) {
        Intent intent = new Intent(this, CreateGestureActivity.class);
        startActivityForResult(intent, REQUEST_NEW_GESTURE);
    }

    // 简单的，没有做用户拒绝的处理
    @Override
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if(requestCode == REQ_PERMISSION_WRITE_STORAGE) {
            for (int i = 0; i < grantResults.length; i++) {
                if (grantResults[i] == PackageManager.PERMISSION_GRANTED) {
                    withPermission();
                }
            }
        }
    }

    private void withPermission() {
        try {
            if(!mStoreFile.exists()){
                if (mStoreFile.createNewFile()) {
                    Log.i("slack", "create Dir:" + mStoreFile.getAbsolutePath() + " success");
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        if (resultCode == RESULT_OK) {
            switch (requestCode) {
                case REQUEST_NEW_GESTURE:
                    loadGestures();
                    break;
            }
        }
    }

    private void loadGestures() {
        if (mTask != null && mTask.getStatus() != GesturesLoadTask.Status.FINISHED) {
            mTask.cancel(true);
        }
        mTask = (GesturesLoadTask) new GesturesLoadTask().execute();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();

        if (mTask != null && mTask.getStatus() != GesturesLoadTask.Status.FINISHED) {
            mTask.cancel(true);
            mTask = null;
        }

        cleanupRenameDialog();
    }

    private void checkForEmpty() {
        if (mAdapter.getCount() == 0) {
            mEmpty.setText(R.string.gestures_empty);
        }
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);

        if (mCurrentRenameGesture != null) {
            outState.putLong(GESTURES_INFO_ID, mCurrentRenameGesture.gesture.getID());
        }
    }

    @Override
    protected void onRestoreInstanceState(Bundle state) {
        super.onRestoreInstanceState(state);

        long id = state.getLong(GESTURES_INFO_ID, -1);
        if (id != -1) {
            final Set<String> entries = sStore.getGestureEntries();
            out:
            for (String name : entries) {
                for (Gesture gesture : sStore.getGestures(name)) {
                    if (gesture.getID() == id) {
                        mCurrentRenameGesture = new NamedGesture();
                        mCurrentRenameGesture.name = name;
                        mCurrentRenameGesture.gesture = gesture;
                        break out;
                    }
                }
            }
        }
    }

    @Override
    public void onCreateContextMenu(ContextMenu menu, View v,
                                    ContextMenu.ContextMenuInfo menuInfo) {
        super.onCreateContextMenu(menu, v, menuInfo);

        AdapterView.AdapterContextMenuInfo info = (AdapterView.AdapterContextMenuInfo) menuInfo;
        menu.setHeaderTitle(((TextView) info.targetView).getText());

        menu.add(0, MENU_ID_RENAME, 0, R.string.gestures_rename);
        menu.add(0, MENU_ID_REMOVE, 0, R.string.gestures_delete);
    }

    @Override
    public boolean onContextItemSelected(MenuItem item) {
        final AdapterView.AdapterContextMenuInfo menuInfo = (AdapterView.AdapterContextMenuInfo)
                item.getMenuInfo();
        final NamedGesture gesture = (NamedGesture) menuInfo.targetView.getTag();

        switch (item.getItemId()) {
            case MENU_ID_RENAME:
                renameGesture(gesture);
                return true;
            case MENU_ID_REMOVE:
                deleteGesture(gesture);
                return true;
        }

        return super.onContextItemSelected(item);
    }

    private void renameGesture(NamedGesture gesture) {
        mCurrentRenameGesture = gesture;
        showDialog(DIALOG_RENAME_GESTURE);
    }

    @Override
    protected Dialog onCreateDialog(int id) {
        if (id == DIALOG_RENAME_GESTURE) {
            return createRenameDialog();
        }
        return super.onCreateDialog(id);
    }

    @Override
    protected void onPrepareDialog(int id, Dialog dialog) {
        super.onPrepareDialog(id, dialog);
        if (id == DIALOG_RENAME_GESTURE) {
            mInput.setText(mCurrentRenameGesture.name);
        }
    }

    private Dialog createRenameDialog() {
        final View layout = View.inflate(this, R.layout.dialog_rename, null);
        mInput = (EditText) layout.findViewById(R.id.name);
        ((TextView) layout.findViewById(R.id.label)).setText(R.string.gestures_rename_label);

        AlertDialog.Builder builder = new AlertDialog.Builder(this);
        builder.setIcon(0);
        builder.setTitle(getString(R.string.gestures_rename_title));
        builder.setCancelable(true);
        builder.setOnCancelListener(new Dialog.OnCancelListener() {
            public void onCancel(DialogInterface dialog) {
                cleanupRenameDialog();
            }
        });
        builder.setNegativeButton(getString(R.string.cancel_action),
                new Dialog.OnClickListener() {
                    public void onClick(DialogInterface dialog, int which) {
                        cleanupRenameDialog();
                    }
                }
        );
//        builder.setNeutralButton(getString(R.string.cancel_action),
//                new Dialog.OnClickListener() {
//                    public void onClick(DialogInterface dialog, int which) {
//                        cleanupRenameDialog();
//                    }
//                }
//        );
        builder.setPositiveButton(getString(R.string.rename_action),
                new Dialog.OnClickListener() {
                    public void onClick(DialogInterface dialog, int which) {
                        changeGestureName();
                    }
                }
        );
        builder.setView(layout);
        return builder.create();
    }

    private void changeGestureName() {
        final String name = mInput.getText().toString();
        if (!TextUtils.isEmpty(name)) {
            final NamedGesture renameGesture = mCurrentRenameGesture;
            final GesturesAdapter adapter = mAdapter;
            final int count = adapter.getCount();

            // Simple linear search, there should not be enough items to warrant
            // a more sophisticated search
            for (int i = 0; i < count; i++) {
                final NamedGesture gesture = adapter.getItem(i);
                if (gesture.gesture.getID() == renameGesture.gesture.getID()) {
                    sStore.removeGesture(gesture.name, gesture.gesture);
                    gesture.name = mInput.getText().toString();
                    sStore.addGesture(gesture.name, gesture.gesture);
                    break;
                }
            }

            adapter.notifyDataSetChanged();
        }
        mCurrentRenameGesture = null;
    }

    private void cleanupRenameDialog() {
        if (mRenameDialog != null) {
            mRenameDialog.dismiss();
            mRenameDialog = null;
        }
        mCurrentRenameGesture = null;
    }

    private void deleteGesture(NamedGesture gesture) {
        sStore.removeGesture(gesture.name, gesture.gesture);
        sStore.save();
        initGestures();// reload

        final GesturesAdapter adapter = mAdapter;
        adapter.setNotifyOnChange(false);
        adapter.remove(gesture);
        adapter.sort(mSorter);
        checkForEmpty();
        adapter.notifyDataSetChanged();

        Toast.makeText(this, R.string.gestures_delete_success, Toast.LENGTH_SHORT).show();
    }

    private class GesturesLoadTask extends AsyncTask<Void, NamedGesture, Integer> {
        private int mThumbnailSize;
        private int mThumbnailInset;// 值越小，图片越大
        private int mPathColor; // 颜色

        @Override
        protected void onPreExecute() {
            super.onPreExecute();

            final Resources resources = getResources();
            mPathColor = resources.getColor(R.color.gesture_color);
            mThumbnailInset = (int) resources.getDimension(R.dimen.gesture_thumbnail_inset);
            mThumbnailSize = (int) resources.getDimension(R.dimen.gesture_thumbnail_size);

            findViewById(R.id.addButton).setEnabled(false);
            findViewById(R.id.reloadButton).setEnabled(false);

            mAdapter.setNotifyOnChange(false);
            mAdapter.clear();
        }

        @Override
        protected Integer doInBackground(Void... params) {
            if (isCancelled()) return STATUS_CANCELLED;
            if (!Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())) {
                return STATUS_NO_STORAGE;
            }

            final GestureLibrary store = sStore;

            if (store.load()) {
                for (String name : store.getGestureEntries()) {
                    if (isCancelled()) break;

                    for (Gesture gesture : store.getGestures(name)) {
                        final Bitmap bitmap = gesture.toBitmap(mThumbnailSize, mThumbnailSize,
                                mThumbnailInset, mPathColor);
                        final NamedGesture namedGesture = new NamedGesture();
                        namedGesture.gesture = gesture;
                        namedGesture.name = name;

                        mAdapter.addBitmap(namedGesture.gesture.getID(), bitmap);
                        publishProgress(namedGesture);
                    }
                }

                return STATUS_SUCCESS;
            }

            return STATUS_NOT_LOADED;
        }

        @Override
        protected void onProgressUpdate(NamedGesture... values) {
            super.onProgressUpdate(values);

            final GesturesAdapter adapter = mAdapter;
            adapter.setNotifyOnChange(false);

            for (NamedGesture gesture : values) {
                adapter.add(gesture);
            }

            adapter.sort(mSorter);
            adapter.notifyDataSetChanged();
        }

        @Override
        protected void onPostExecute(Integer result) {
            super.onPostExecute(result);

            if (result == STATUS_NO_STORAGE) {
                getListView().setVisibility(View.GONE);
                mEmpty.setVisibility(View.VISIBLE);
                mEmpty.setText(getString(R.string.gestures_error_loading,
                        mStoreFile.getAbsolutePath()));
            } else {
                findViewById(R.id.addButton).setEnabled(true);
                findViewById(R.id.reloadButton).setEnabled(true);
                checkForEmpty();
            }
        }
    }

    static class NamedGesture {
        String name;
        Gesture gesture;
    }

    private class GesturesAdapter extends ArrayAdapter<NamedGesture> {
        private final LayoutInflater mInflater;
        private final Map<Long, Drawable> mThumbnails = Collections.synchronizedMap(
                new HashMap<Long, Drawable>());

        public GesturesAdapter(Context context) {
            super(context, 0);
            mInflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
        }

        void addBitmap(Long id, Bitmap bitmap) {
            mThumbnails.put(id, new BitmapDrawable(bitmap));
        }

        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            if (convertView == null) {
                convertView = mInflater.inflate(R.layout.gestures_item, parent, false);
            }

            final NamedGesture gesture = getItem(position);
            final TextView label = (TextView) convertView;

            label.setTag(gesture);
            label.setText(gesture.name);
            label.setCompoundDrawablesWithIntrinsicBounds(mThumbnails.get(gesture.gesture.getID()),
                    null, null, null);

            return convertView;
        }
    }
}



CL_slacking
关注
专栏目录
android手势识别
12-27
android 手势识别 demo
Android实现自定义手势和识别手势的功能
01-04
1. 先完成自定义手势的Activity 1.1 因为需要存储手势文件所以需要声明权限： <uses android:name=android.permission.READ_EXTERNAL_STORAGE> //读取SD卡权限 <uses android:name=android.permission.WRITE_...
理解Android的手势识别
noodies的专栏
10-28 4985
对于触摸屏，其原生的消息无非按下、抬起、移动这几种，我们只需要简单重载onTouch或者设置触摸侦听器setOnTouchListener即可进行处理。不过，为了提高我们的APP的用户体验，有时候我们需要识别用户的手势，Android给我们提供的手势识别工具GestureDetector就可以帮上大忙了。 基础 GestureDetector的工作原理是，当我们接收到用户触摸消息时
Android 手势识别
路漫漫其修远兮
01-20 1872
手势识别 原理：Android手势识别其实和我们平常对触摸事件的处理是一样的，都是对MotionEvent事件进行计算处理。 Android为我们提供了两个基本的手势识别。 GestureDetector:单手势识别，可以识别按下，单击，双击，长按，滑动，fling滑动。 ScaleGestureDetector:缩放手势识别， 1. GestureDetector单手势识别 GestureDetector中有两个重要接口， OnGestureListener，识别单次点击，滑动，fling滑动的接口
Android 手势识别——单击/双击
weixin_33738555的博客
12-30 352
为什么需要手势识别？ 手势对于我们的app有很多的地方都在使用，比如右滑关闭界面等。手势控制分为触发动作（Touch Mechanics，用户手指在屏幕上如何动作）和触发行为（Touch Activities，界面上特定动作在特定情境下引发的结果）。这是因为同样的触发动作（如单次触击）在不同情境下可能会带来不同的结果（如轻触，取消，开启／关闭指示），同样单次触发行为（如放大）可能是由...
Android-手势识别
weixin_30363509的博客
01-12 97
1.常用手势 andorid中手机交互的执行过程 1.手指触碰屏幕，触发MotionEvent事件 2.该事件可以被onTouchListener监听 3.通过 GestureDetector（该类是手势的一个封装类）转发我们的手指触碰事件给OnG...
基于百度手势识别API实现 Android隔空手势
08-06
这里我们讨论的是如何利用百度的AI技术，特别是其手势识别API，来实现在Android应用中隔空手势的功能。百度的手势识别API是基于深度学习的，能够高效准确地识别多种手势，为开发者提供了强大的工具。 首先，要使用...
Android 触屏手势识别GestureTest
03-16
Android手势识别概述 Android系统提供了一个名为`GestureDetector`的类，用于检测和处理简单的滑动、点击等手势。同时，`SimpleOnGestureListener`是`GestureDetector`的子类，提供了一些基本手势的回调方法，如`...
Android View进行手势识别详解
09-01
在Android应用开发中，手势识别是一项重要的功能，它允许用户通过触摸屏幕的不同方式与应用程序进行交互。本篇文章将深入探讨如何在Android View中实现手势识别，以便为用户提供更丰富的交互体验。 首先，Android...
Android 手势识别的API简单使用
10-04
对GestureOverlayView， GestureDetector，SimpleOnGestureListener的简单使用。
Android Gesture Detector
xiangyong2008的专栏
04-21 883
感谢android中国开发者的众多先驱，本文主要内容来自于总结，一小部分是自己的体会。主要参考文章为： http://www.williamhua.com/2009/04/23/android-touchscreen-gesture-recogniton/http://goro.javaeye.com/blog/402163 Android Touch Screen 与传统
Android的手势识别
九师兄
05-16 1444
首先，在Android系统中，每一次手势交互都会依照以下顺序执行。 接触接触屏一刹那，触发一个MotionEvent事件。 该事件被OnTouchListener监听，在其onTouch()方法里获得该MotionEvent对象。 通过GestureDetector（手势识别器）转发次MotionEvent对象至OnGestureListener。 OnGestureListener获得该对象，听根
Android手势识别
克瑞所呈的专栏
08-01 535
1.Android中手势交互的执行顺序 1.手指触碰屏幕时，触发MotionEvent事件！ 2.该事件被OnTouchListener监听，可在它的onTouch()方法中获得该MotionEvent对象！ 3.通过GestureDetector转发MotionEvent对象给OnGestureListener 4.我们可以通过OnGestureListener获得该对象，然后获取相关信息
Android GestureDetector手势识别实战指南
"Android手势操作简单实例讲解" 在Android开发中，手势操作是用户体验的重要组成部分，让用户能够通过自然的手势与应用进行交互。本教程将深入介绍如何在Android中实现简单的手势识别，主要依赖于`GestureDetector`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值