jkanji 3.x开发瞻望 - 基于 mini2440 电阻式触摸屏（4...- 数独游戏(三) 自定义对话框等等

当前位置: 编程技术>移动开发

本页文章导读:

▪jkanji 3.x开发瞻望 jkanji 3.x开发展望首先，我最希望能改善一下用户界面。其次，是我最想说的（如果有人在意的话）——手写板功能可能只是个绰头——我只是试试可不可以在java上跑tomoe，事实是：能，但.........

▪ 基于 mini2440 电阻式触摸屏（4）：mini2440触摸屏驱动分析基于 mini2440 电阻式触摸屏（四）：mini2440触摸屏驱动分析参考：http://blog.chinaunix.net/uid-22174347-id-1786941.html ========================================================== 开发环境编译系统：fedora9 编译器.........

▪ 数独游戏(三) 自定义对话框等等数独游戏(3) 自定义对话框等等自定义对话框 1.需要继承 Dialog 类， 2.并要定义一个有参构造函数（因为父类里面没有无参构造函数） 3.重写 onCreate方法，一切操作将在此方法进行流程：为.........

[1]jkanji 3.x开发瞻望

来源: 互联网发布时间: 2014-02-18

jkanji 3.x开发展望

首先，我最希望能改善一下用户界面。

其次，是我最想说的（如果有人在意的话）——手写板功能可能只是个绰头——我只是试试可不可以在java上跑tomoe，事实是：能，但不快。那是tomoe算法和我自身水平的问题，我觉得如果有更专业的知识，可能会有更好的识别率，这里只能抱歉地说，目前只能如此。

其三，加强日语语法方面的功能。

其四，实现一个健壮的青空文库阅读器。从目前的情况看，这是有可能的，但测试和写代码会很累。

[2] 基于 mini2440 电阻式触摸屏（4）：mini2440触摸屏驱动分析

来源: 互联网发布时间: 2014-02-18

基于 mini2440 电阻式触摸屏（四）：mini2440触摸屏驱动分析

参考：http://blog.chinaunix.net/uid-22174347-id-1786941.html

==========================================================

开发环境

编译系统：fedora9

编译器：arm-linux-4.4.3

主控芯片：S3C2440

开发板：mini2440

==========================================================

一、电阻式触摸屏工作原理
二、 S3C2440 电阻式触摸屏接口、内部ADC结构
三、Linux输入子系统(InputSubsystem)
四、mini2440触摸屏驱动分析

==========================================================

（这部分转自：http://blog.chinaunix.net/uid-22174347-id-1786941.html 文章写得很好）

四、mini2440触摸屏驱动分析

1、硬件原理图分析

S3c2440芯片内部触摸屏接口与ADC接口是集成在一起的，硬件结构原理图请看：S3C2440上ADC驱动实例开发讲解中的图，其中通道7(XP或AIN7)作为触摸屏接口的X坐标输入，通道5(YP或AIN5)作为触摸屏接口的Y坐标输入。在"S3C2440上ADC驱动实例开发讲解"中，AD转换的模拟信号是由开发板上的一个电位器产生并通过通道1(AIN0)输入的，而这里的模拟信号则是由点触触摸屏所产生的X坐标和Y坐标两个模拟信号，并分别通过通道7和通道5输入。S3c2440提供的触摸屏接口有4种处理模式，分别是：正常转换模式、单独的X/Y位置转换模式、自动X/Y位置转换模式和等待中断模式，对于在每种模式下工作的要求，请详细查看数据手册的描述。本驱动实例将采用自动X/Y位置转换模式和等待中断模式。

注意：在每步中，为了让代码逻辑更加有条理和容易理解，就没有考虑代码的顺序，比如函数要先定义后调用。如果要编译此代码，请严格按照C语言的规范来调整代码的顺序。

2、建立触摸屏驱动程序my2440_ts.c，首先实现加载和卸载部分，在驱动加载部分，我们主要做的事情是：启用ADC所需要的时钟、映射IO口、初始化寄存器、申请中断、初始化输入设备、将输入设备注册到输入子系统。代码如下：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/clk.h>
#include <linux/init.h>
#include <linux/input.h>
#include <linux/serio.h>
#include <plat/regs-adc.h>
#include <asm/irq.h>
#include <asm/io.h>
 
/*用于保存从平台时钟列表中获取的ADC时钟*/
static struct clk *adc_clk;

/*定义了一个用来保存经过虚拟映射后的内存地址*/
static void __iomem *adc_base;

/*定义一个输入设备来表示我们的触摸屏设备*/
static struct input_dev *ts_dev;

/*设备名称*/
#define DEVICE_NAME    "my2440_TouchScreen"

/*定义一个WAIT4INT宏，该宏将对ADC触摸屏控制寄存器进行操作
S3C2410_ADCTSC_YM_SEN这些宏都定义在regs-adc.h中*/
#define WAIT4INT(x)    (((x)<<8) | S3C2410_ADCTSC_YM_SEN | S3C2410_ADCTSC_YP_SEN | \
                    S3C2410_ADCTSC_XP_SEN | S3C2410_ADCTSC_XY_PST(3))

static int __init ts_init(void)
{
    int ret;

    /*从平台时钟队列中获取ADC的时钟，这里为什么要取得这个时钟，因为ADC的转换频率跟时钟有关。
    系统的一些时钟定义在arch/arm/plat-s3c24xx/s3c2410-clock.c中*/
    adc_clk = clk_get(NULL, "adc");
    if(!adc_clk)
    {
        /*错误处理*/
        printk(KERN_ERR "falied to find adc clock source\n");
        return -ENOENT;
    }

    /*时钟获取后要使能后才可以使用，clk_enable定义在arch/arm/plat-s3c/clock.c中*/
    clk_enable(adc_clk);

    /*将ADC的IO端口占用的这段IO空间映射到内存的虚拟地址，ioremap定义在io.h中。
     注意：IO空间要映射后才能使用，以后对虚拟地址的操作就是对IO空间的操作,
     S3C2410_PA_ADC是ADC控制器的基地址，定义在mach-s3c2410/include/mach/map.h中，0x20是虚拟地址长度大小*/
    adc_base = ioremap(S3C2410_PA_ADC, 0x20);
    if(adc_base == NULL)
    {
        /*错误处理*/
        printk(KERN_ERR "failed to remap register block\n");
        ret = -EINVAL;
        goto err_noclk;
    }

    /*初始化ADC控制寄存器和ADC触摸屏控制寄存器*/
    adc_initialize();

    /*申请ADC中断，AD转换完成后触发。这里使用共享中断IRQF_SHARED是因为该中断号在ADC驱动中也使用了，
    最后一个参数1是随便给的一个值，因为如果不给值设为NULL的话，中断就申请不成功*/
    ret = request_irq(IRQ_ADC, adc_irq, IRQF_SHARED | IRQF_SAMPLE_RANDOM, DEVICE_NAME, 1);
    if(ret)
    {
        printk(KERN_ERR "IRQ%d error %d\n", IRQ_ADC, ret);
        ret = -EINVAL;
        goto err_nomap;
    }

    /*申请触摸屏中断，对触摸屏按下或提笔时触发*/
    ret = request_irq(IRQ_TC, tc_irq, IRQF_SAMPLE_RANDOM, DEVICE_NAME, 1);
    if(ret)
    {
        printk(KERN_ERR "IRQ%d error %d\n", IRQ_TC, ret);
        ret = -EINVAL;
        goto err_noirq;
    }

    /*给输入设备申请空间，input_allocate_device定义在input.h中*/
    ts_dev = input_allocate_device();

    /*下面初始化输入设备，即给输入设备结构体input_dev的成员设置值。
    evbit字段用于描述支持的事件，这里支持同步事件、按键事件、绝对坐标事件，
    BIT宏实际就是对1进行位操作，定义在linux/bitops.h中*/
    ts_dev->evbit[0] = BIT(EV_SYN) | BIT(EV_KEY) | BIT(EV_ABS); 
    
    /*keybit字段用于描述按键的类型，在input.h中定义了很多，这里用BTN_TOUCH类型来表示触摸屏的点击*/
    ts_dev->keybit[BITS_TO_LONGS(BTN_TOUCH)] = BIT(BTN_TOUCH);

    /*对于触摸屏来说，使用的是绝对坐标系统。这里设置该坐标系统中X和Y坐标的最小值和最大值(0-1023范围)
    ABS_X和ABS_Y就表示X坐标和Y坐标，ABS_PRESSURE就表示触摸屏是按下还是抬起状态*/
    input_set_abs_params(ts_dev, ABS_X, 0, 0x3FF, 0, 0);
    input_set_abs_params(ts_dev, ABS_Y, 0, 0x3FF, 0, 0);
    input_set_abs_params(ts_dev, ABS_PRESSURE, 0, 1, 0, 0);

    /*以下是设置触摸屏输入设备的身份信息，直接在这里写死。
    这些信息可以在驱动挂载后在/proc/bus/input/devices中查看到*/
    ts_dev->name          = DEVICE_NAME;   /*设备名称*/
    ts_dev->id.bustype    = BUS_RS232;     /*总线类型*/    
    ts_dev->id.vendor     = 0xDEAD;        /*经销商ID号*/
    ts_dev->id.product    = 0xBEEF;        /*产品ID号*/
    ts_dev->id.version    = 0x0101;        /*版本ID号*/

    /*好了，一些都准备就绪，现在就把ts_dev触摸屏设备注册到输入子系统中*/
    input_register_device(ts_dev);

    return 0;

/*下面是错误跳转处理*/
err_noclk:
    clk_disable(adc_clk);
    clk_put(adc_clk);

err_nomap:
    iounmap(adc_base);

err_noirq:
    free_irq(IRQ_ADC, 1);

    return ret;
}

/*初始化ADC控制寄存器和ADC触摸屏控制寄存器*/
static void adc_initialize(void)
{
    /*计算结果为(二进制)：111111111000000，再根据数据手册得知
    此处是将AD转换预定标器值设为255、AD转换预定标器使能有效*/
    writel(S3C2410_ADCCON_PRSCEN | S3C2410_ADCCON_PRSCVL(0xFF), adc_base + S3C2410_ADCCON);

    /*对ADC开始延时寄存器进行设置，延时值为0xffff*/
    writel(0xffff, adc_base + S3C2410_ADCDLY);

    /*WAIT4INT宏计算结果为(二进制)：11010011，再根据数据手册得知
    此处是将ADC触摸屏控制寄存器设置成等待中断模式*/
    writel(WAIT4INT(0), adc_base + S3C2410_ADCTSC);
}

static void __exit ts_exit(void)
{
    /*屏蔽和释放中断*/
    disable_irq(IRQ_ADC);
    disable_irq(IRQ_TC);
    free_irq(IRQ_ADC, 1);
    free_irq(IRQ_TC, 1);

    /*释放虚拟地址映射空间*/
    iounmap(adc_base);

    /*屏蔽和销毁时钟*/
    if(adc_clk)
    {
        clk_disable(adc_clk);
        clk_put(adc_clk);
        adc_clk = NULL;
    }

    /*将触摸屏设备从输入子系统中注销*/
    input_unregister_device(ts_dev);
}

module_init(ts_init);
module_exit(ts_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("s3c2440 tp");
MODULE_DESCRIPTION("My2440 Touch Screen Driver");

2、接下来要做的是，在两个中断服务程序中实现触摸屏状态和坐标的转换。先看代码，如下：

/*定义一个外部的信号量ADC_LOCK，因为ADC_LOCK在ADC驱动程序中已申明
这样就能保证ADC资源在ADC驱动和触摸屏驱动中进行互斥访问*/
extern struct semaphore ADC_LOCK;

/*做为一个标签，只有对触摸屏操作后才对X和Y坐标进行转换*/
static int OwnADC = 0;

/*用于记录转换后的X坐标值和Y坐标值*/
static long xp;
static long yp;

/*用于计数对触摸屏压下或抬起时模拟输入转换的次数*/
static int count;

/*定义一个AUTOPST宏，将ADC触摸屏控制寄存器设置成自动转换模式*/
#define AUTOPST    (S3C2410_ADCTSC_YM_SEN | S3C2410_ADCTSC_YP_SEN | S3C2410_ADCTSC_XP_SEN | \
                S3C2410_ADCTSC_AUTO_PST | S3C2410_ADCTSC_XY_PST(0))


/*触摸屏中断服务程序，对触摸屏按下或提笔时触发执行*/
static irqreturn_t tc_irq(int irq, void *dev_id)
{
    /*用于记录这一次AD转换后的值*/
    unsigned long data0;
    unsigned long data1;

    /*用于记录触摸屏操作状态是按下还是抬起*/
    int updown;

    /*ADC资源可以获取，即上锁*/
    if (down_trylock(&ADC_LOCK) == 0)
    {
        /*标识对触摸屏进行了操作*/
        OwnADC = 1;

        /*读取这一次AD转换后的值，注意这次主要读的是状态*/
        data0 = readl(adc_base + S3C2410_ADCDAT0);
        data1 = readl(adc_base + S3C2410_ADCDAT1);

        /*记录这一次对触摸屏是压下还是抬起，该状态保存在数据寄存器的第15位，所以与上S3C2410_ADCDAT0_UPDOWN*/
        updown = (!(data0 & S3C2410_ADCDAT0_UPDOWN)) && (!(data1 & S3C2410_ADCDAT0_UPDOWN));

        /*判断触摸屏的操作状态*/
        if (updown) 
        {
            /*如果是按下状态，则调用touch_timer_fire函数来启动ADC转换，该函数定义后面再讲*/
            touch_timer_fire(0);
        } 
        else 
        {
            /*如果是抬起状态，就结束了这一次的操作，所以就释放ADC资源的占有*/
            OwnADC = 0;
            up(&ADC_LOCK);
        }
    }

    return IRQ_HANDLED;
}

static void touch_timer_fire(unsigned long data)
{
    /*用于记录这一次AD转换后的值*/
      unsigned long data0;
      unsigned long data1;

    /*用于记录触摸屏操作状态是按下还是抬起*/
    int updown;

    /*读取这一次AD转换后的值，注意这次主要读的是状态*/
      data0 = readl(adc_base + S3C2410_ADCDAT0);
    data1 = readl(adc_base + S3C2410_ADCDAT1);

    /*记录这一次对触摸屏是压下还是抬起，该状态保存在数据寄存器的第15位，所以与上S3C2410_ADCDAT0_UPDOWN*/
     updown = (!(data0 & S3C2410_ADCDAT0_UPDOWN)) && (!(data1 & S3C2410_ADCDAT0_UPDOWN));

    /*判断触摸屏的操作状态*/
     if (updown) 
    {
        /*如果状态是按下，并且ADC已经转换了就报告事件和数据*/
         if (count != 0) 
        {
            long tmp;
                                                                                                 
            tmp = xp;
            xp = yp;
            yp = tmp;
                                                                                                 
            xp >>= 2;
            yp >>= 2;

#ifdef CONFIG_TOUCHSCREEN_MY2440_DEBUG
            /*触摸屏调试信息，编译内核时选上此项后，点击触摸屏会在终端上打印出坐标信息*/
            struct timeval tv;
            do_gettimeofday(&tv);
            printk(KERN_DEBUG "T: %06d, X: %03ld, Y: %03ld\n", (int)tv.tv_usec, xp, yp);
#endif

            /*报告X、Y的绝对坐标值*/
             input_report_abs(ts_dev, ABS_X, xp);
             input_report_abs(ts_dev, ABS_Y, yp);

            /*报告触摸屏的状态，1表明触摸屏被按下*/
            input_report_abs(ts_dev, ABS_PRESSURE, 1);

            /*报告按键事件，键值为1(代表触摸屏对应的按键被按下)*/
             input_report_key(ts_dev, BTN_TOUCH, 1);

            /*等待接收方受到数据后回复确认，用于同步*/
             input_sync(ts_dev); 
         }

        /*如果状态是按下，并且ADC还没有开始转换就启动ADC进行转换*/
         xp = 0;
         yp = 0;
         count = 0;

        /*设置触摸屏的模式为自动转换模式*/
         writel(S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST, adc_base + S3C2410_ADCTSC);

        /*启动ADC转换*/
         writel(readl(adc_base + S3C2410_ADCCON) | S3C2410_ADCCON_ENABLE_START, adc_base + S3C2410_ADCCON);
     } 
    else 
    {
        /*否则是抬起状态*/
         count = 0;

        /*报告按键事件，键值为0(代表触摸屏对应的按键被释放)*/
         input_report_key(ts_dev, BTN_TOUCH, 0);

        /*报告触摸屏的状态，0表明触摸屏没被按下*/
         input_report_abs(ts_dev, ABS_PRESSURE, 0);

        /*等待接收方受到数据后回复确认，用于同步*/
         input_sync(ts_dev);

        /*将触摸屏重新设置为等待中断状态*/
         writel(WAIT4INT(0), adc_base + S3C2410_ADCTSC);

        /*如果触摸屏抬起，就意味着这一次的操作结束，所以就释放ADC资源的占有*/
        if (OwnADC) 
        {
            OwnADC = 0;
            up(&ADC_LOCK);
        }
     }
}

/*定义并初始化了一个定时器touch_timer，定时器服务程序为touch_timer_fire*/
static struct timer_list touch_timer = TIMER_INITIALIZER(touch_timer_fire, 0, 0);

/*ADC中断服务程序，AD转换完成后触发执行*/
static irqreturn_t adc_irq(int irq, void *dev_id)
{
    /*用于记录这一次AD转换后的值*/
    unsigned long data0;
    unsigned long data1;

    if(OwnADC)
    {
        /*读取这一次AD转换后的值，注意这次主要读的是坐标*/
        data0 = readl(adc_base + S3C2410_ADCDAT0);
        data1 = readl(adc_base + S3C2410_ADCDAT1);

        /*记录这一次通过AD转换后的X坐标值和Y坐标值，根据数据手册可知，X和Y坐标转换数值
        分别保存在数据寄存器0和1的第0-9位，所以这里与上S3C2410_ADCDAT0_XPDATA_MASK就是取0-9位的值*/
        xp += data0 & S3C2410_ADCDAT0_XPDATA_MASK;
        yp += data1 & S3C2410_ADCDAT1_YPDATA_MASK;

        /*计数这一次AD转换的次数*/
        count++;

        if (count < (1<<2)) 
        {
            /*如果转换的次数小于4，则重新启动ADC转换*/
            writel(S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST, adc_base + S3C2410_ADCTSC);
            writel(readl(adc_base + S3C2410_ADCCON) | S3C2410_ADCCON_ENABLE_START, adc_base + S3C2410_ADCCON);
        } 
        else 
        {
            /*否则，启动1个时间滴答的定时器，这是就会去执行定时器服务程序上报事件和数据*/
            mod_timer(&touch_timer, jiffies + 1);
            writel(WAIT4INT(1), adc_base + S3C2410_ADCTSC);
        }
    }

    return IRQ_HANDLED;
}

3、我们从整体上描述转换这个的过程：

(1)如果触摸屏感觉到触摸，则触发触摸屏中断即进入tc_irq，获取ADC_LOCK后判断触摸屏状态为按下，则调用touch_timer_fire启动ADC转换；

(2)当ADC转换启动后，触发ADC中断即进入adc_irq，如果这一次转换的次数小于4，则重新启动ADC进行转换，如果4次完毕后，启动1个时间滴答的定时器，停止ADC转换，也就是说在这个时间滴答内，ADC转换是停止的；

(3)这里为什么要在1个时间滴答到来之前停止ADC的转换呢？这是为了防止屏幕抖动。

(4)如果1个时间滴答到来则进入定时器服务程序touch_timer_fire，判断触摸屏仍然处于按下状态则上报事件和转换的数据，并重启ADC转换，重复第(2)步；

(5)如果触摸抬起了，则上报释放事件，并将触摸屏重新设置为等待中断状态。

4、整体流程如下图所示

[3] 数独游戏(三) 自定义对话框等等

来源: 互联网发布时间: 2014-02-18

数独游戏(3) 自定义对话框等等

自定义对话框

1.需要继承 Dialog 类，

2.并要定义一个有参构造函数（因为父类里面没有无参构造函数）

3.重写 onCreate方法，一切操作将在此方法进行

流程：

为每个按钮添加监听事件，

刷新九宫格里的数字，也就是重新绘制画面（在view类中调用 invalidate();），

更新备选数字数组（每次修改之后都得进行重新计算不可用的值 calculateAllUsedTiles() ; ）

ShuduView.java

package com.soduku;

import com.soduku.R;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Paint.FontMetrics;
import android.view.MotionEvent;
import android.view.View;

public class ShuduView extends View {
	
	//单元格的宽度和高度
	private float width ;
	private float height ;
	
	private Game game = new Game();
	
	public ShuduView(Context context)
	{
		super(context);
	}
	
	//w:整个 veiw 的宽度;  h:整个 veiw 的高度

	@Override
	protected void onSizeChanged(int w, int h, int oldw, int oldh) {
		// TODO Auto-generated method stub
		//把整个屏幕分成 九宫格 的每个格子的宽度和高度
		this.width = w/9f ;
		this.height = h/9f ;
		
		super.onSizeChanged(w, h, oldw, oldh);
	}


	@Override
	public void onDraw(Canvas canvas) {
		
		
		
		Paint backgroundPaint = new Paint();
		//从配置文件中 获取颜色值
		backgroundPaint.setColor(this.getResources().getColor(R.color.shudu_background));
		//画出整个手机屏幕的 的背景色
		canvas.drawRect(0, 0, this.getWidth(), this.getHeight(), backgroundPaint);
		
		//----------------------------------------
		
		Paint darkPaint = new Paint();
		darkPaint.setColor(this.getResources().getColor(R.color.shudu_dark));
		
		Paint hilitePaint = new Paint();
		hilitePaint.setColor(this.getResources().getColor(R.color.shudu_hilite));
		
		Paint lightPaint = new Paint();
		lightPaint.setColor(this.getResources().getColor(R.color.shudu_light));
		
		//画九宫格里面的 横线，纵线,每次画出的线要想达到某种效果，需画两条 之间格1像素的位置，且颜色也要搭配好
		for(int i = 0 ; i < 9 ; i++ )
		{
			canvas.drawLine(0, i*height, this.getWidth(), i*height, lightPaint);
			canvas.drawLine(0, i*height+1, this.getWidth(), i*height+1, hilitePaint);
		    
			canvas.drawLine(i*width,0, i*width, this.getHeight(), lightPaint);
			canvas.drawLine(i*width+1,0, i*width+1, this.getHeight(), hilitePaint);
		}
		
		//把整个 屏幕的格子 分成9个大的 9 宫格，每个大的9宫格 里面又有9个小格，   实际上就是 用颜色比较深的线隔开
		for(int i = 0 ; i < 9 ; i ++)
		{
			if(i%3 != 0)
			{
				continue ;
			}
			
			canvas.drawLine(0, i*height, this.getWidth(), i*height, darkPaint);
			canvas.drawLine(0, i*height+1, this.getWidth(), i*height+1, hilitePaint);
		    
			canvas.drawLine(i*width,0, i*width, this.getHeight(), darkPaint);
			canvas.drawLine(i*width+1,0, i*width+1, this.getHeight(), hilitePaint);
			
		}
		
		//设置在表格上显示的数字
		Paint numberPaint = new Paint();
		
		numberPaint.setColor(Color.BLACK);
		numberPaint.setStyle(Paint.Style.STROKE); //让其画出来的东西是 空的
		numberPaint.setTextSize(height*0.75f); //设置字体大小
		numberPaint.setTextAlign(Paint.Align.CENTER); //让字体居中
		
		float x = width/2f ;
		//调整字体的位置 （ 度量）  比如居中,调整垂直方向上的居中
		FontMetrics fm = numberPaint.getFontMetrics();
		// 这些  fm.ascent 都是基于 基准线 而言
		float y = height/2f - (fm.ascent+fm.descent)/2 ;
		//System.out.println("y："+y+"fm.ascent:"+fm.ascent+"fm.descent:"+fm.descent);
		
		//初始化数据
		for(int i = 0 ; i < 9 ; i ++)
		{
			for(int j = 0 ; j < 9 ; j ++)
			{
				
				canvas.drawText(game.getTileString(i, j), i*width+x,j*height+y , numberPaint);
			}
		}
		
		super.onDraw(canvas);
	}
	
	int selectedX ;
	int selectedY ;
	//鼠标（手） 触动 手机屏幕 事件,当 手 触动 该 view 时 该函数会被调用
	@Override
	public boolean onTouchEvent(MotionEvent event) {
		
		if( event.getAction() != event.ACTION_DOWN )
		{
			return super.onTouchEvent(event);
		}
		
		//获取 点击 哪个单元格的坐标
		selectedX = (int)(event.getX()/width) ;
		selectedY = (int)(event.getY()/height) ;
		
		//把获取某单元格 不可用的数据
		int used[] = game.getUsedTilesByCoor(selectedX, selectedY);
		
		//把获取某单元格 不可用的数据 打印出来
//		for(int i = 0 ; i < used.length ; i ++)
//		{
//			System.out.println(used[i]);
//		}
		
		KeyDialog keyDialog = new KeyDialog(this.getContext(),used,this) ;
		
		keyDialog.show() ;
		
		
		
		return true;
	}
	
	//刷新整个九宫格里的数据
	public void setSelectedTile(int tile)
	{
		if(game.setTileIfValid(selectedX, selectedY, tile))
		{
			invalidate();//重新绘制整个视图，也就相当于 重新生成一次该对象
		}
	}

}

KeyDialog.java (自定义对话框)

调用 dismiss()方法从屏幕上移除对话框

package com.soduku;

import android.app.Dialog;
import android.content.Context;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

//实现一个自定义对话框功能，需继承 Dialog类
public class KeyDialog extends Dialog {
	//用来存放代表对话框 中 按钮的对象
	private final View[] keys = new View[9] ;
	
	private final int used[] ;//用于存放 已使用过的数据
	
	//这里如果设置为（final）终态，则会报错，因为对象 是可以改变的
	private ShuduView shuduView = null ;
	
	//第二个参数就是接收传过来的 不可用的数据，然后保存在成员变量数组中
	public KeyDialog(Context context, int[] used , ShuduView shuduView) {
		super(context);
		this.used = used ;
		this.shuduView = shuduView ;
		// TODO Auto-generated constructor stub
	}
	
	//需要重写  onCreate方法，当一个Dialog第一次显示的时候，系统会调用该方法
	@Override
	public void onCreate(Bundle savedInstanceState) {
		// TODO Auto-generated method stub
		//设置对话框中有哪些组件(以对话框的形式显示在屏幕上)，这里使用一个了xml布局文件，通过调用 R.layout.keypad
		setContentView(R.layout.keypad) ;
		
		setTitle("可选数字");
		
		findViews() ;//把按钮对象添加到keys数组中
		
		//把不可用的数字按钮 设为不可见
		
		for(int i = 0 ; i < used.length ; i ++)
		{
			if(used[i] != 0)
			{
				//设置不可用的按钮  可见度： 不可见
				keys[ used[i]-1 ].setVisibility(View.INVISIBLE);
			}
		}
		//为每个键设置的监听器
		setKeyListeners();
		
		//为 返回按钮 设置监听器
		Button back_Button = (Button)findViewById(R.id.back_1);
		back_Button.setOnClickListener( new View.OnClickListener(){
			
			public void onClick(View v)
			{
				dismiss();// 把对话框 从屏幕上移除
			}
			
		
		});
		
		super.onCreate(savedInstanceState);
	}
	
	//把按钮对象添加到keys数组中
	public void findViews()
	{
		keys[0] = findViewById(R.id.keypad_1) ;
		keys[1] = findViewById(R.id.keypad_2) ;
		keys[2] = findViewById(R.id.keypad_3) ;
		keys[3] = findViewById(R.id.keypad_4) ;
		keys[4] = findViewById(R.id.keypad_5) ;
		keys[5] = findViewById(R.id.keypad_6) ;
		keys[6] = findViewById(R.id.keypad_7) ;
		keys[7] = findViewById(R.id.keypad_8) ;
		keys[8] = findViewById(R.id.keypad_9) ;
		
	}
	//为每个键(按钮)设置监听器
	public void setKeyListeners()
	{
		for(int i = 0 ; i < keys.length ; i ++)
		{
			final int t = i + 1 ;
			//使用内部类的方式
			keys[i].setOnClickListener(new View.OnClickListener(){
				
				public void onClick(View v)
				{
					returnResult(t); //t的值将是 填在单元格上的数字
				}
			});
		}
	}
	
	//通知 ShuduView对象，刷新整个九宫格里的数据，
	public void returnResult(int tile)
	{
		shuduView.setSelectedTile(tile);
		dismiss(); // 把对话框 从屏幕上移除
	}

}

keypad.xml （监听器的布局文件）

<?xml version="1.0" encoding="utf-8"?>
<TableLayout xmlns:android="http://schemas.android.com/apk/res/android"
    
    android:id="@+id/keypad"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:orientation="vertical" >
    
    <TableRow>
        
        <Button android:id="@+id/keypad_1"
            android:text="@string/keypad_1">
        </Button>
        
        <Button android:id="@+id/keypad_2" 
            android:text="@string/keypad_2">
        </Button>
        
        <Button android:id="@+id/keypad_3" 
            android:text="@string/keypad_3">
        </Button>
        
    </TableRow>
     
    <TableRow>
        <Button android:id="@+id/keypad_4" 
            android:text="@string/keypad_4">
        </Button>
        
        <Button android:id="@+id/keypad_5" 
            android:text="@string/keypad_5">
        </Button>
        
        <Button android:id="@+id/keypad_6" 
            android:text="@string/keypad_6">
        </Button>
    </TableRow>
              
    <TableRow>
        <Button android:id="@+id/keypad_7" 
            android:text="@string/keypad_7">
        </Button>
        
        <Button android:id="@+id/keypad_8" 
            android:text="@string/keypad_8">
        </Button>
        
        <Button android:id="@+id/keypad_9" 
            android:text="@string/keypad_9">
        </Button>
    </TableRow>

    <TableRow>
        
        <Button
            android:text="确定" 
        >          
        </Button>
        
        <Button
            android:text="中立" 
        >          
        </Button>
        
        <Button android:id="@+id/back_1"
            android:text="@string/back_1" 
        >          
        </Button>
    </TableRow>

</TableLayout>

Game.java （具体的逻辑处理类）

package com.soduku;

public class Game {
	
	//初始化 九宫格的数据
	private final String initStr =
			"360000000004230800000004200"+
	        "070460003820000014500013020"+
			"001900000007048300000000045";
	//定义一个 数组 存放 初始化数据，首先 要将 initStr里面的数据分离开，存放在数组里
	private int[] shuduku = new int[9*9] ;
	
	//用于存储 已经使用过的 数据
	private int[][][] used = new int[9][9][]  ;
	
	public Game()
	{
		shuduku = fromPuzzleString(initStr) ;	
		calculateAllUsedTiles() ; //一创建对象的时候，就把每个单元格中 不可用的数据存到 三维数组里
	}
	
	//通过传来的坐标值，获取 该坐标 的 具体值（整数）
	private int getTile(int x , int y)
	{
		return shuduku[y*9+x] ;
	}
	
	public String getTileString(int x , int y)
	{
		int v = getTile(x , y);
		if(0 == v)
			return "" ;
		else

		    return String.valueOf(v); //把获取的 整数 转成 字符串
	}
	
	//把字符串 一个个分离出来，存放至 shudu数组中，通过返回值，赋值给 shuduku数组中
	public int[] fromPuzzleString(String str)
	{
		int[] shudu = new int[str.length()] ;
		
		for(int i = 0 ; i < str.length() ; i++)
		{
			shudu[i] = str.charAt(i) - '0' ; //把获取的单个字符减去 '0' 转成整数，赋给 整形 shudu数组中
		}
		
		return shudu ;
	}
	
	//用于计算 所有单元格中 不可用的 数据，返回一个 一维数组赋值给 三维数组 
	public void calculateAllUsedTiles()
	{
		for(int i = 0 ; i < 9 ; i++)
		{
			for(int j = 0 ; j < 9 ; j ++)
			{
				// 这里的 数组 赋值，只要 它们 加起来 是 三维 即可，假如是 四维 也一样
				used[i][j] = calculateUsedTiles(i , j) ;
			}
		}
	}
	
	// 取出某个单元格中 不可用的 数
	public int[] getUsedTilesByCoor(int x , int y )
	{
		return used[x][y] ;
	}
	
	
	//用于计算  某一单元格 已经不可用的 数据
	public int[] calculateUsedTiles(int x , int y)
	{
		
		int[] c = new int[9] ;
		
		//计算 该单元格中  列上不可用的数据
		for(int i =0 ; i < 9 ; i++ )
		{
			// 在 该选中的单元格 中 不需计算
			if(i == y)
				continue ;
			
			int t = getTile(x, i) ;
			
			if(t != 0)
			   c[t-1] = t ;
			
		}
		
		//计算 该单元格中 行上不可用的数据
		for(int i =0 ; i < 9 ; i++ )
		{
			// 在 该选中的单元格 中 不需计算
			if(i == x)
				continue ;
			
			int t = getTile(i, y) ;
			
			if(t != 0)
			   c[t-1] = t ;
			
		}
		
		//用于计算一个九宫格 里面不可用的数据
		
		int startX = (x/3)*3 ;
		int startY = (y/3)*3 ;
		
		for(int i = startX ; i < startX + 3 ; i ++)
		{
			for(int j = startY ; j < startY + 3 ; j ++)
			{
				if(i == x && j == y)
				     continue ;
				
				int t = getTile(i, j) ;
				
				if(t != 0)
				   c[t-1] = t ;
			}
		}
		
		// 经过 上面的程序 检测出不可用的数据，存在c数组中，由于还有一些没有 赋值，默认为 0，需要进行压缩，把默认设置为0的数组值，进行删除
		
		// 把数组里面为0 的数 过滤 掉，用 nused 来标识有几个不为0的数
		int nused = 0 ;
		
		for(int t : c)
		{
			if(t != 0)
				nused ++ ;
		}
		
		int[] c1 = new int[nused] ;
		nused = 0 ;
		for(int t : c)
		{
			if(t != 0)
			{
				c1[nused++] = t ;
			}
		}	
		
		return c1;
	}
	//把用户选的字，设置到 soduku数组中
	public boolean setTileIfValid(int x , int y , int value)
	{
		// 取出某个单元格中 不可用的 数
		int tiles[] = getUsedTilesByCoor(x, y);
		
		if(value != 0)
		{
			for(int tile : tiles)
			{
				//如果用户选的数字和 “ 不可用数组” 里面的数字相同，则返回false，
				if(tile == value)
				{
					return false ;
				}
			}
		}
		
		setTile(x,y,value) ;
		
		//每次修改之后都得 进行重新计算 不可用的值
		calculateAllUsedTiles() ;
		
		return true;
	}
	//进行修改 数独数组 里的值
	private void setTile(int x , int y , int value)
	{
		shuduku[9*y+x] = value ;
	}

}