一个基于android的拼图游戏问题。希望有人帮我改进

  mGvPuzzleMainDetail.setOnItemClickListener(new OnItemClickListener() {            @Override
            public void onItemClick(AdapterView<?> arg0, View view,
                                    int position, long arg3) {
                // 判断是否可移动
                if (GameUtil.isMoveable(position)) {
                    // 交换点击Item与空格的位置
                    GameUtil.swapItems(
                            GameUtil.mItemBeans.get(position),
                            GameUtil.mBlankItemBean);
                    // 重新获取图片
                    recreateData();
                    // 通知GridView更改UI
                    mAdapter.notifyDataSetChanged();
                    // 更新步数
                    COUNT_INDEX++;
                    mTvPuzzleMainCounts.setText("" + COUNT_INDEX);
                    // 判断是否成功
                    if (GameUtil.isSuccess()) {
                        // 将最后一张图显示完整
                        recreateData();
                        mBitmapItemLists.remove(TYPE * TYPE - 1);
                        mBitmapItemLists.add(mLastBitmap);
                        // 通知GridView更改UI
                        mAdapter.notifyDataSetChanged();                        //添加一个汉字声音                       gameshengyin();
                        Toast.makeText(PuzzleActivity.this, "小朋友，恭喜你拼图成功!",
                                Toast.LENGTH_LONG).show();
                        mGvPuzzleMainDetail.setEnabled(false);
                        mTimer.cancel();
                        mTimerTask.cancel();
                    }
                }
            }
        }); private  void gameshengyin (){
        if( mPicSelected){
            MediaPlayer mMediaPlayer;
            mMediaPlayer= MediaPlayer.create(this, R.raw.audio);
            mMediaPlayer.start();
        }    }我的声音函数该怎么写，Main函数
private void initData() {
        TEMP_IMAGE_PATH =
                Environment.getExternalStorageDirectory().getPath() + "/temp.png";  //获取图片路径
        mResPicId = new int[]{    //存放图片ID数组
                R.mipmap.pic1, R.mipmap.pic2, R.mipmap.pic3, R.mipmap.pic4, R.mipmap.pic5, R.mipmap.pic6
                , R.mipmap.pic7, R.mipmap.pic8, R.mipmap.pic9, R.mipmap.pic10, R.mipmap.pic11, R.mipmap.pic12
                , R.mipmap.pic13, R.mipmap.pic14, R.mipmap.pic15, R.mipmap.plus
        };        Bitmap[] bitmaps = new Bitmap[mResPicId.length];//图片ID的长度
        mPicList = new ArrayList<>();  //动态数组
        for (int i = 0; i < bitmaps.length; i++) {
            bitmaps[i] = BitmapFactory.decodeResource(getResources(), mResPicId[i]);
            mPicList.add(bitmaps[i]);
        }    }
怎么在拼图结束后，通过对比图片ID自动播放音频。求大神，求联系方式

增加一个hashmap，key是图片id，value是动物名称，和你的mResPicId一样写死在那就行了

仔细看了一下
如果你的游戏是动态的，参照1楼说的
如果你的游戏是写死的，直接把音频放在指定目录
最后然后把R.raw.audio改成语言播放或对应的图即可

TEMP_IMAGE_PATH =
                Environment.getExternalStorageDirectory().getPath() + "/temp.png";  //获取图片路径
这个不应该这样写，直接上一个intent传过来就行了，这样也减少了耦合性
上一个intent应该这样写        startActivity(new Intent(this,拼图界面.class)
                .putExtra("imgRes",R.drawable.小马资源)
                .putExtra("radioRes","小马音频"));裁剪随机等应该在拼图界面操作，如下
        //获取传过来的拼图资源
        int imgRes = getIntent().getIntExtra("imgRes", 0);
        //...在本界面做裁剪随机等

        //获取传过来的音频资源
        int radioRes = getIntent().getIntExtra("radioRes", 0);

        //当点击时播放radioRes即可

你的功能看着基本实现了啊，只是思路不对。上面发的就是思路啊。
你原有的思路：用户点击某张图片，随机裁剪后保存到本地，没有任何传参直接跳到拼图界面>拼图页读取本地图片>死胡同，无法判断图片及语音
改进的思路：用户点击某张图片>通过intent的方式将该图片的res和语音的res传到拼图界面>拼图界面进行裁剪及随机>当拼图完成，播放传过来的语音

mainactivitypublic class MainActivity extends AppCompatActivity implements View.OnClickListener {    // 返回码：系统图库
    private static final int RESULT_IMAGE = 100;
    // 返回码：相机
    private static final int RESULT_CAMERA = 200;
    // IMAGE TYPE
    private static final String IMAGE_TYPE = "image/*";
    // 权限
    private static final int MY_PERMISSIONS_REQUEST_WRITE_EXTERNAL = 1;
    // Temp照片路径
    public static String TEMP_IMAGE_PATH;
    // GridView 显示图片
    private GridView mGvPicList;
    private List<Bitmap> mPicList;
    // 主页图片资源ID
    private int[] mResPicId;    private LayoutInflater mLayoutInflater;
    private PopupWindow mPopupWindow;
    private View mPopupView;
    private TextView mTvType2;
    private TextView mTvType3;
    private TextView mTvType4;    // 游戏类型N*N
    private int mType = 2;
    // 本地图册、相机选择
    private String[] mCustomItems = new String[]{"本地图册", "相机拍照"};
    private TextView mTvSelected;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);        initData();
        initView();
    }    private void initData() {
        TEMP_IMAGE_PATH =
                Environment.getExternalStorageDirectory().getPath() + "/temp.png";  //获取图片路径
        mResPicId = new int[]{    //存放图片ID数组
                R.mipmap.pic1, R.mipmap.pic2, R.mipmap.pic3, R.mipmap.pic4, R.mipmap.pic5, R.mipmap.pic6
                , R.mipmap.pic7, R.mipmap.pic8, R.mipmap.pic9, R.mipmap.pic10, R.mipmap.pic11, R.mipmap.pic12
                , R.mipmap.pic13, R.mipmap.pic14, R.mipmap.pic15, R.mipmap.plus
        };        Bitmap[] bitmaps = new Bitmap[mResPicId.length];//图片ID的长度
        mPicList = new ArrayList <>();  //动态数组
        for (int i = 0; i < bitmaps.length; i++) {
            bitmaps[i] = BitmapFactory.decodeResource(getResources(), mResPicId[i]);
            mPicList.add(bitmaps[i]);
        }    }    private void initView() {
        mTvSelected = (TextView) findViewById(R.id.tv_puzzle_main_type_selected);//难度选择
        mGvPicList = (GridView) findViewById(R.id.gv_xpuzzle_main_pic_list);  //游戏图片选择
        mGvPicList.setAdapter(new GridPicListAdapter(MainActivity.this, mPicList));
        mLayoutInflater = (LayoutInflater) getSystemService(
                LAYOUT_INFLATER_SERVICE);
        // mType view
        mPopupView = mLayoutInflater.inflate(
                R.layout.xpuzzle_main_type_selected, null);  //null?   调用难度选择页面
        mTvType2 = (TextView) mPopupView.findViewById(R.id.tv_main_type_2);//设定 mTvType2为2x2难度
        mTvType3 = (TextView) mPopupView.findViewById(R.id.tv_main_type_3);//设定 mTvType3为3x3难度
        mTvType4 = (TextView) mPopupView.findViewById(R.id.tv_main_type_4); //设定 mTvType4为4x4难度        initListener();  //调用initListener函数
    }    private void initListener() {  //分别给不同的难度设定按钮监听器
        mTvType2.setOnClickListener(this);
        mTvType3.setOnClickListener(this);
        mTvType4.setOnClickListener(this);        mTvSelected.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                showLevel(v);
            }
        }/*this*/); //点击展示等级        mGvPicList.setOnItemClickListener(new AdapterView.OnItemClickListener() {
            @Override
            public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
                if (position == mResPicId.length - 1) {
                    //更多选择,调用本地
                    showLocalPhoto();  //调用showlocalphoto
                } else {
                    //跳转到游戏
                    Intent intent = new Intent(MainActivity.this, PuzzleActivity.class); //跳转到puzzleActivity开始游戏
                    intent.putExtra("mType", mType);
                    intent.putExtra("picSelectedID", mResPicId[position]);
                    startActivity(intent);
                }
            }
        });    }    private void showLocalPhoto() {
        // 权限
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            if (ContextCompat.checkSelfPermission(MainActivity.this,
                    Manifest.permission.WRITE_EXTERNAL_STORAGE)
                    != PackageManager.PERMISSION_GRANTED) {                ActivityCompat.requestPermissions(MainActivity.this,
                        new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
                        MY_PERMISSIONS_REQUEST_WRITE_EXTERNAL);
            }
        }        AlertDialog.Builder builder = new AlertDialog.Builder(MainActivity.this);
        builder.setTitle("请选择图片来源: ");
        builder.setItems(mCustomItems, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                if (0 == which) {          //本地相册获取图片
                    Intent intent = new Intent(Intent.ACTION_PICK, null);
                    intent.setDataAndType(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, IMAGE_TYPE);
                    startActivityForResult(intent, RESULT_IMAGE);
                } else if (1 == which) {         //调用照相机获取图片
                    Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                    Uri pathUri = Uri.fromFile(new File(TEMP_IMAGE_PATH));//照相机7.0适配问题
                    intent.putExtra(MediaStore.EXTRA_OUTPUT, pathUri);
                    startActivityForResult(intent, RESULT_CAMERA);
                }
            }
        });        builder.create().show();
    }    private void showLevel(View view) {    //？？？
        int density = (int) SchemeUtils.getDensity(this);
        mPopupWindow = new PopupWindow(mPopupView, 200 * density, 50 * density);        mPopupWindow.setFocusable(true);
        mPopupWindow.setOutsideTouchable(true);
        Drawable transparent = new ColorDrawable(Color.TRANSPARENT);
        mPopupWindow.setBackgroundDrawable(transparent);
        int[] location = new int[2];
        view.getLocationOnScreen(location);
        mPopupWindow.showAtLocation(
                view,
                Gravity.NO_GRAVITY,
                location[0] - 40 * density,
                location[1] + 30 * density);
    }    @Override
    public void onClick(View v) {          //点击选择难度
        switch (v.getId()) {
            // Type
            case R.id.tv_main_type_2:
                mType = 2;
                mTvSelected.setText(" 2 X 2 ");
                break;
            case R.id.tv_main_type_3:
                mType = 3;
                mTvSelected.setText(" 3 X 3 ");
                break;
            case R.id.tv_main_type_4:
                mType = 4;
                mTvSelected.setText(" 4 X 4 ");
                break;
            case R.id.tv_puzzle_main_type_selected:
//                showLevel(v);
//                使用这种方式时，难度选择框无法弹出
                break;
            default:
                break;
        }
        mPopupWindow.dismiss();
    }    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (resultCode == RESULT_OK) {
            if (requestCode == RESULT_CAMERA /*&& data != null*/) {
                // 相机
                Intent intent = new Intent(MainActivity.this, PuzzleActivity.class);//跳转到游戏界面
                intent.putExtra("mType", mType);    //获取难度类型
                intent.putExtra("mPicPath", TEMP_IMAGE_PATH);   //图片获取路径
                startActivity(intent);
            } else if (requestCode == RESULT_IMAGE && data != null) {
                // 相册
                Cursor cursor = this.getContentResolver().query(data.getData(), null, null, null, null);
                cursor.moveToFirst();
                String imagePath = cursor.getString(cursor.getColumnIndex("_data"));
                Intent intent = new Intent(MainActivity.this, PuzzleActivity

public class MainActivity extends AppCompatActivity implements View.OnClickListener {    // 返回码：系统图库
    private static final int RESULT_IMAGE = 100;
    // 返回码：相机
    private static final int RESULT_CAMERA = 200;
    // IMAGE TYPE
    private static final String IMAGE_TYPE = "image/*";
    // 权限
    private static final int MY_PERMISSIONS_REQUEST_WRITE_EXTERNAL = 1;
    // Temp照片路径
    public static String TEMP_IMAGE_PATH;
    // GridView 显示图片
    private GridView mGvPicList;
    private List<Bitmap> mPicList;
    // 主页图片资源ID
    private int[] mResPicId;    private LayoutInflater mLayoutInflater;
    private PopupWindow mPopupWindow;
    private View mPopupView;
    private TextView mTvType2;
    private TextView mTvType3;
    private TextView mTvType4;    // 游戏类型N*N
    private int mType = 2;
    // 本地图册、相机选择
    private String[] mCustomItems = new String[]{"本地图册", "相机拍照"};
    private TextView mTvSelected;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);        initData();
        initView();
    }    private void initData() {
        TEMP_IMAGE_PATH =
                Environment.getExternalStorageDirectory().getPath() + "/temp.png";  //获取图片路径
        mResPicId = new int[]{    //存放图片ID数组
                R.mipmap.pic1, R.mipmap.pic2, R.mipmap.pic3, R.mipmap.pic4, R.mipmap.pic5, R.mipmap.pic6
                , R.mipmap.pic7, R.mipmap.pic8, R.mipmap.pic9, R.mipmap.pic10, R.mipmap.pic11, R.mipmap.pic12
                , R.mipmap.pic13, R.mipmap.pic14, R.mipmap.pic15, R.mipmap.plus
        };        Bitmap[] bitmaps = new Bitmap[mResPicId.length];//图片ID的长度
        mPicList = new ArrayList <>();  //动态数组
        for (int i = 0; i < bitmaps.length; i++) {
            bitmaps[i] = BitmapFactory.decodeResource(getResources(), mResPicId[i]);
            mPicList.add(bitmaps[i]);
        }    }    private void initView() {
        mTvSelected = (TextView) findViewById(R.id.tv_puzzle_main_type_selected);//难度选择
        mGvPicList = (GridView) findViewById(R.id.gv_xpuzzle_main_pic_list);  //游戏图片选择
        mGvPicList.setAdapter(new GridPicListAdapter(MainActivity.this, mPicList));
        mLayoutInflater = (LayoutInflater) getSystemService(
                LAYOUT_INFLATER_SERVICE);
        // mType view
        mPopupView = mLayoutInflater.inflate(
                R.layout.xpuzzle_main_type_selected, null);  //null?   调用难度选择页面
        mTvType2 = (TextView) mPopupView.findViewById(R.id.tv_main_type_2);//设定 mTvType2为2x2难度
        mTvType3 = (TextView) mPopupView.findViewById(R.id.tv_main_type_3);//设定 mTvType3为3x3难度
        mTvType4 = (TextView) mPopupView.findViewById(R.id.tv_main_type_4); //设定 mTvType4为4x4难度        initListener();  //调用initListener函数
    }    private void initListener() {  //分别给不同的难度设定按钮监听器
        mTvType2.setOnClickListener(this);
        mTvType3.setOnClickListener(this);
        mTvType4.setOnClickListener(this);        mTvSelected.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                showLevel(v);
            }
        }/*this*/); //点击展示等级        mGvPicList.setOnItemClickListener(new AdapterView.OnItemClickListener() {
            @Override
            public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
                if (position == mResPicId.length - 1) {
                    //更多选择,调用本地
                    showLocalPhoto();  //调用showlocalphoto
                } else {
                    //跳转到游戏
                    Intent intent = new Intent(MainActivity.this, PuzzleActivity.class); //跳转到puzzleActivity开始游戏
                    intent.putExtra("mType", mType);
                    intent.putExtra("picSelectedID", mResPicId[position]);
                    startActivity(intent);
                }
            }
        });    }    private void showLocalPhoto() {
        // 权限
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            if (ContextCompat.checkSelfPermission(MainActivity.this,
                    Manifest.permission.WRITE_EXTERNAL_STORAGE)
                    != PackageManager.PERMISSION_GRANTED) {                ActivityCompat.requestPermissions(MainActivity.this,
                        new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
                        MY_PERMISSIONS_REQUEST_WRITE_EXTERNAL);
            }
        }        AlertDialog.Builder builder = new AlertDialog.Builder(MainActivity.this);
        builder.setTitle("请选择图片来源: ");
        builder.setItems(mCustomItems, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                if (0 == which) {          //本地相册获取图片
                    Intent intent = new Intent(Intent.ACTION_PICK, null);
                    intent.setDataAndType(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, IMAGE_TYPE);
                    startActivityForResult(intent, RESULT_IMAGE);
                } else if (1 == which) {         //调用照相机获取图片
                    Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                    Uri pathUri = Uri.fromFile(new File(TEMP_IMAGE_PATH));//照相机7.0适配问题
                    intent.putExtra(MediaStore.EXTRA_OUTPUT, pathUri);
                    startActivityForResult(intent, RESULT_CAMERA);
                }
            }
        });        builder.create().show();
    }    private void showLevel(View view) {    //？？？
        int density = (int) SchemeUtils.getDensity(this);
        mPopupWindow = new PopupWindow(mPopupView, 200 * density, 50 * density);        mPopupWindow.setFocusable(true);
        mPopupWindow.setOutsideTouchable(true);
        Drawable transparent = new ColorDrawable(Color.TRANSPARENT);
        mPopupWindow.setBackgroundDrawable(transparent);
        int[] location = new int[2];
        view.getLocationOnScreen(location);
        mPopupWindow.showAtLocation(
                view,
                Gravity.NO_GRAVITY,
                location[0] - 40 * density,
                location[1] + 30 * density);
    }    @Override
    public void onClick(View v) {          //点击选择难度
        switch (v.getId()) {
            // Type
            case R.id.tv_main_type_2:
                mType = 2;
                mTvSelected.setText(" 2 X 2 ");
                break;
            case R.id.tv_main_type_3:
                mType = 3;
                mTvSelected.setText(" 3 X 3 ");
                break;
            case R.id.tv_main_type_4:
                mType = 4;
                mTvSelected.setText(" 4 X 4 ");
                break;
            case R.id.tv_puzzle_main_type_selected:
//                showLevel(v);
//                使用这种方式时，难度选择框无法弹出
                break;
            default:
                break;
        }
        mPopupWindow.dismiss();
    }    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (resultCode == RESULT_OK) {
            if (requestCode == RESULT_CAMERA /*&& data != null*/) {
                // 相机
                Intent intent = new Intent(MainActivity.this, PuzzleActivity.class);//跳转到游戏界面
                intent.putExtra("mType", mType);    //获取难度类型
                intent.putExtra("mPicPath", TEMP_IMAGE_PATH);   //图片获取路径
                startActivity(intent);
            } else if (requestCode == RESULT_IMAGE && data != null) {
                // 相册
                Cursor cursor = this.getContentResolver().query(data.getData(), null, null, null, null);
                cursor.moveToFirst();
                String imagePath = cursor.getString(cursor.getColumnIndex("_data"));
                Intent intent = new Intent(MainActivity.this, PuzzleActivity.class);  //跳转到游戏界面
                intent.putExtra("mType", mType);    //获取难度类型
                intent.putExtra("mPicPath", imagePath);
                startActivity(intent);
            }
        }
    }    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        if (requestCode == MY_PERMISSIONS_REQUEST_WRITE_EXTERNAL) {    //获取权限判断
            if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                Toast.makeText(MainActivity.this, "申请成功", Toast.LENGTH_SHORT).show();
            } else {
                Toast.makeText(MainActivity.this, "权限拒绝,无法使用部分功能", Toast.LENGTH_SHORT).show();
            }
            return;
        }
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    }
    public static void startActivity(Context context) {  //欢迎界面函数
        Intent in = new Intent(context,MainActivity.class);
        context.startActivity(in);
    }
}

public class PuzzleActivity extends Activity implements OnClickListener {
    public static Bitmap mLastBitmap;
    public static int TYPE = 2;
    public static int COUNT_INDEX = 0;   //走动次数
    public static int TIMER_INDEX = 0;    //时间
    private Handler mHandler = new Handler() {        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 1:
                    // 更新计时器
                    TIMER_INDEX++;
                    mTvTimer.setText("" + TIMER_INDEX);
                    break;
                default:
                    break;
            }
        }
    };
    // 选择的图片
    private Bitmap mPicSelected;
    private GridView mGvPuzzleMainDetail;
    private int mResId;
    private String mPicPath;
    private ImageView mImageView;
    private Button mBtnBack;
    private Button mBtnImage;
    private Button mBtnRestart;
    private TextView mTvPuzzleMainCounts;
    private TextView mTvTimer;
    // 切图后的图片
    private List<Bitmap> mBitmapItemLists = new ArrayList<Bitmap>();
    private GridItemsAdapter mAdapter;
    // Flag 是否已显示原图
    private boolean mIsShowImg;
    private Timer mTimer;
    private TimerTask mTimerTask;    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.xpuzzle_puzzle_detail_main);  //游戏页面
        // 获取选择的图片
        Bitmap picSelectedTemp;
        // 选择默认图片还是自定义图片
        mResId = getIntent().getExtras().getInt("picSelectedID");  //默认图片
        mPicPath = getIntent().getExtras().getString("mPicPath");//自定义图片
        if (mResId != 0) {
            picSelectedTemp = BitmapFactory.decodeResource(
                    getResources(), mResId);
        } else {
            picSelectedTemp = BitmapFactory.decodeFile(mPicPath);
        }
        TYPE = getIntent().getExtras().getInt("mType", 2);
        // 对图片处理
        handlerImage(picSelectedTemp);        initViews();
        // 生成游戏数据
        generateGame();        mGvPuzzleMainDetail.setOnItemClickListener(new OnItemClickListener() {            @Override
            public void onItemClick(AdapterView<?> arg0, View view,
                                    int position, long arg3) {
                // 判断是否可移动
                if (GameUtil.isMoveable(position)) {
                    // 交换点击Item与空格的位置
                    GameUtil.swapItems(
                            GameUtil.mItemBeans.get(position),
                            GameUtil.mBlankItemBean);
                    // 重新获取图片
                    recreateData();
                    // 通知GridView更改UI
                    mAdapter.notifyDataSetChanged();
                    // 更新步数
                    COUNT_INDEX++;
                    mTvPuzzleMainCounts.setText("" + COUNT_INDEX);
                    // 判断是否成功
                    if (GameUtil.isSuccess()) {
                        // 将最后一张图显示完整
                        recreateData();
                        mBitmapItemLists.remove(TYPE * TYPE - 1);
                        mBitmapItemLists.add(mLastBitmap);
                        // 通知GridView更改UI
                        mAdapter.notifyDataSetChanged();                        //添加一个汉字声音                       //gameshengyin();
                        Toast.makeText(PuzzleActivity.this, "小朋友，恭喜你拼图成功!",
                                Toast.LENGTH_LONG).show();
                        mGvPuzzleMainDetail.setEnabled(false);
                        mTimer.cancel();
                        mTimerTask.cancel();
                    }
                }
            }
        });
        // 返回按钮点击事件
        mBtnBack.setOnClickListener(this);
        // 显示原图按钮点击事件
        mBtnImage.setOnClickListener(this);
        // 重置按钮点击事件
        mBtnRestart.setOnClickListener(this);
    }    /**
     * Button点击事件
     */
    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            // 返回按钮点击事件
            case R.id.btn_puzzle_main_back:
                PuzzleActivity.this.finish();
                break;
            // 显示原图按钮点击事件
            case R.id.btn_puzzle_main_img:
                Animation animShow = AnimationUtils.loadAnimation(
                        PuzzleActivity.this, R.anim.image_show_anim);
                Animation animHide = AnimationUtils.loadAnimation(
                        PuzzleActivity.this, R.anim.image_hide_anim);
                if (mIsShowImg) {
                    mImageView.startAnimation(animHide);
                    mImageView.setVisibility(View.GONE);
                    mIsShowImg = false;
                } else {
                    mImageView.startAnimation(animShow);
                    mImageView.setVisibility(View.VISIBLE);
                    mIsShowImg = true;
                }
                break;
            // 重置按钮点击事件
            case R.id.btn_puzzle_main_restart:
                cleanConfig();
                generateGame();
                recreateData();
                // 通知GridView更改UI
                mTvPuzzleMainCounts.setText("" + COUNT_INDEX);
                mAdapter.notifyDataSetChanged();
                mGvPuzzleMainDetail.setEnabled(true);
                break;
            default:
                break;
        }
    }
  /*  private  void gameshengyin (){
        if( mPicSelected){
            MediaPlayer mMediaPlayer;
            mMediaPlayer= MediaPlayer.create(this, R.raw.audio);
            mMediaPlayer.start();
        }    }*/
    /**
     * 生成游戏数据
     */
    private void generateGame() {
        // 切图获取初始拼图数据正常顺序
        new ImagesUtil().createInitBitmaps(
                TYPE, mPicSelected, PuzzleActivity.this);
        // 生成随机数据
        GameUtil.getPuzzleGenerator();
        // 获取Bitmap集合
        for (ItemBean temp : GameUtil.mItemBeans) {
            mBitmapItemLists.add(temp.getBitmap());
        }
        // 数据适配器
        mAdapter = new GridItemsAdapter(this, mBitmapItemLists);
        mGvPuzzleMainDetail.setAdapter(mAdapter);
        // 启用计时器
        mTimer = new Timer(true);
        // 计时器线程
        mTimerTask = new TimerTask() {            @Override
            public void run() {
                Message msg = new Message();
                msg.what = 1;
                mHandler.sendMessage(msg);
            }
        };
        // 每1000ms执行延迟0s
        mTimer.schedule(mTimerTask, 0, 1000);
    }    /**
     * 添加显示原图的View
     */
    private void addImgView() {
        RelativeLayout relativeLayout = (RelativeLayout) findViewById(
                R.id.rl_puzzle_main_main_layout);
        mImageView = new ImageView(PuzzleActivity.this);
        mImageView.setImageBitmap(mPicSelected);
        int x = (int) (mPicSelected.getWidth() * 0.9F);
        int y = (int) (mPicSelected.getHeight() * 0.9F);
        LayoutParams params = new LayoutParams(x, y);
        params.addRule(RelativeLayout.CENTER_IN_PARENT);
        mImageView.setLayoutParams(params);
        relativeLayout.addView(mImageView);
        mImageView.setVisibility(View.GONE);
    }    /**
     * 返回时调用
     */
    @Override
    protected void onStop() {
        super.onStop();
        // 清空相关参数设置
        cleanConfig();
        this.finish();
    }    /**
     * 清空相关参数设置
     */
    private void cleanConfig() {
        // 清空相关参数设置
        GameUtil.mItemBeans.clear();
        // 停止计时器
        mTimer.cancel();
        mTimerTask.cancel();
        COUNT_INDEX = 0;
        TIMER_INDEX = 0;
        // 清除拍摄的照片
        if (mPicPath != null) {
            // 删除照片
            File file = new File(MainActivity.TEMP_IMAGE_PATH);
            if (file.exists()) {
                file.delete();
            }
        }
    }    /**
     * 重新获取图片
     */
    private void recreateData() {//将重新生成后的Bitmap依次加载到Bitmap的list中
        mBitmapItemLists.clear();
        for (ItemBean temp : GameUtil.mItemBeans) {
            mBitmapItemLists.add(temp.getBitmap());
        }
    }    /**
     * 对图片处理自适应大小
     *
     * @param bitmap bitmap
     */
    private void handlerImage(Bitmap bitmap) {
        // 将图片放大到固定尺寸
        int screenWidth = SchemeUtils.getDisplayMetrics(this).widthPixels;
        int screenHeigt = SchemeUtils.getDisplayMetrics(this).heightPixels;
        mPicSelected = new ImagesUtil().resizeBitmap(
                screenWidth * 0.8f, screenHeigt * 0.6f, bitmap);
    }    /**
     * 初始化Views
     */
    private void initViews() {
        // Button
        mBtnBack = (Button) findViewById(R.id.btn_puzzle_main_back);
        mBtnImage = (Button) findViewById(R.id.btn_puzzle_main_img);
        mBtnRestart = (Button) findViewById(R.id.btn_puzzle_main_restart);
        // Flag 是否已显示原图
        mIsShowImg = false;
        // GridView
        mGvPuzzleMainDetail = (GridView) findViewById(
                R.id.gv_puzzle_main_detail);
        // 设置为N*N显示
        mGvPuzzleMainDetail.setNumColumns(TYPE);
        LayoutParams gridParams = new LayoutParams(
                mPicSelected.getWidth(),
                mPicSelected.getHeight());
        // 水平居中
        gridParams.addRule(RelativeLayout.CENTER_HORIZONTAL);
        // 其他格式属性
        gridParams.addRule(
                RelativeLayout.BELOW,
                R.id.ll_puzzle_main_spinner);
        // Grid显示
        mGvPuzzleMainDetail.setLayoutParams(gridParams);
        mGvPuzzleMainDetail.setHorizontalSpacing(0);
        mGvPuzzleMainDetail.setVerticalSpacing(0);
        // TV步数
        mTvPuzzleMainCounts = (TextView) findViewById(
                R.id.tv_puzzle_main_counts);
        mTvPuzzleMainCounts.setText("" + COUNT_INDEX);
        // TV计时器
        mTvTimer = (TextView) findViewById(R.id.tv_puzzle_main_time);
        mTvTimer.setText("0秒");
        // 添加显示原图的View
        addImgView();
    }
}

mResPicId = new int[]{    //存放图片ID数组
                R.mipmap.pic1, R.mipmap.pic2, R.mipmap.pic3, R.mipmap.pic4, R.mipmap.pic5, R.mipmap.pic6
                , R.mipmap.pic7, R.mipmap.pic8, R.mipmap.pic9, R.mipmap.pic10, R.mipmap.pic11, R.mipmap.pic12
                , R.mipmap.pic13, R.mipmap.pic14, R.mipmap.pic15, R.mipmap.plus
        };//在此处加上
mResVoid=new int[]{...}
                    //跳转到游戏
                    Intent intent = new Intent(MainActivity.this, PuzzleActivity.class); //跳转到puzzleActivity开始游戏
                    intent.putExtra("mType", mType);
                    intent.putExtra("picSelectedID", mResPicId[position]);
                    //在此处加上
                    intent.putExtra("radioRes",mResVoid[position]);然后就是另一个界面，如果是自己的图片就播放声音
mNowVoid = getIntent().getIntExtra("radioRes", 0);mMediaPlayer= MediaPlayer.create(this, mNowVoid);
            mMediaPlayer.start();

你贴的代码就少了一个radioRes而已，咋就想不通呢

之前我以为你的图是随机的哥哥，有问题还可以再问你吗，谢谢哥哥。我还在解决的路上
radioRes..这个是干什么用的啊
TEMP_IMAGE_PATH =
Environment.getExternalStorageDirectory().getPath() + "/temp.png"; //获取图片路径
这个可以不要是吗

你把MediaPlayer声明为全局变量，当ActivityDestroy是调用stop相关方法，你自己查一下MediaPlayer相关的东西

private void showLocalPhoto() {
        // 权限
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            if (ContextCompat.checkSelfPermission(MainActivity.this,
                    Manifest.permission.WRITE_EXTERNAL_STORAGE)
                    != PackageManager.PERMISSION_GRANTED) {                ActivityCompat.requestPermissions(MainActivity.this,
                        new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
                        MY_PERMISSIONS_REQUEST_WRITE_EXTERNAL);
            }
        }        AlertDialog.Builder builder = new AlertDialog.Builder(MainActivity.this);
        builder.setTitle("请选择图片来源: ");
        builder.setItems(mCustomItems, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                if (0 == which) {          //本地相册获取图片
                    Intent intent = new Intent(Intent.ACTION_PICK, null);
                    intent.setDataAndType(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, IMAGE_TYPE);
                    startActivityForResult(intent, RESULT_IMAGE);
                } else if (1 == which) {         //调用照相机获取图片
                    Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                    Uri pathUri = Uri.fromFile(new File(TEMP_IMAGE_PATH));//照相机7.0适配问题
                    intent.putExtra(MediaStore.EXTRA_OUTPUT, pathUri);
                    startActivityForResult(intent, RESULT_CAMERA);
                }
            }
        });        builder.create().show();哥哥，安卓7.0相机适配问题您会修改吗。之前我一直在查，在研究，还是不会修改。现在只有7.0以下的手机才可以用Uri
7.0后，不再使用Uri为了隐私保护。
您帮我看看应该怎么修改

mGvPuzzleMainDetail.setOnItemClickListener(new OnItemClickListener() {            @Override
            public void onItemClick(AdapterView<?> arg0, View view,
                                    int position, long arg3) {
                // 判断是否可移动
                if (GameUtil.isMoveable(position)) {
                    // 交换点击Item与空格的位置
                    GameUtil.swapItems(
                            GameUtil.mItemBeans.get(position),
                            GameUtil.mBlankItemBean);
                    // 重新获取图片
                    recreateData();
                    // 通知GridView更改UI
                    mAdapter.notifyDataSetChanged();
                    // 更新步数
                    COUNT_INDEX++;
                    mTvPuzzleMainCounts.setText("" + COUNT_INDEX);
                    // 判断是否成功
                    if (GameUtil.isSuccess()) {
                        // 将最后一张图显示完整
                        recreateData();
                        mBitmapItemLists.remove(TYPE * TYPE - 1);
                        mBitmapItemLists.add(mLastBitmap);
                        // 通知GridView更改UI
                        mAdapter.notifyDataSetChanged();                        Toast.makeText(PuzzleActivity.this, "小朋友，恭喜你拼图成功!",
                                Toast.LENGTH_LONG).show();
                        mGvPuzzleMainDetail.setEnabled(false);
                        mTimer.cancel();
                        mTimerTask.cancel();
                        mMediaPlayer.stop();
                    }                }
            }
        });    mMediaPlayer.stop();放在  放在了这里，这样的话点进去游戏后只有完成游戏才会停止音乐。如果返回还是会播放音乐。这个有办法解决吗哥哥。

stop的地方不对，Activity不是有onDestroy吗，当然放在这里了    @Override
    protected void onDestroy() {
        if (mMediaPlayer != null) {
            mMediaPlayer.stop();
        }
        super.onDestroy();
    }

E/HAL: load: id=gralloc != hmi->id=gralloc之前报错

用文字转语音，TTS

大神  我想问您一个问题
   public static boolean isMoveable(int position) {//position为点击Item的ItemId，通
        // 过和blank的ItemId进行比较，来判断二者是否相邻。
        int type = PuzzleActivity.TYPE;
        // 获取空格Item
        int blankId = GameUtil.mBlankItemBean.getItemId() - 1;
        // 不同行相差为type
        if (Math.abs(blankId - position) == type) {
            return true;}
        // 相同行相差为1
        if ((blankId / type == position / type) &&
                Math.abs(blankId - position) == 1) {
            return true;
        }
        return false;
    }(blankId / type == position / type)这个条件是指什么
怎么运算的。我怎么算都不想等。

没太清楚你想干嘛
(blankId / type == position / type)这个的意思就是blankId和position相差不能超过type等同于（ Math.abs(blankId - position)<type）这个你只要debug到那一行，然后对着等于号alt+鼠标左键即可看到是否相等，对着等号左边的/号会看到左边表达式的结果，对着变量会看到变量的值，对着方法、表达式就会看到返回值

我懂你意思了谢谢  我之前一直以为理解错了。  还有哥哥
GridItemsAdapter
GridPicListAdapterpublic class GridItemsAdapter extends BaseAdapter {    // 映射List
    private List<Bitmap> mBitmapItemLists;
    private Context mContext;    public GridItemsAdapter(Context mContext, List<Bitmap> picList) {
        this.mContext = mContext;
        this.mBitmapItemLists = picList;
    }    @Override
    public int getCount() {
        return mBitmapItemLists.size();
    }    @Override
    public Object getItem(int position) {
        return mBitmapItemLists.get(position);
    }    @Override
    public long getItemId(int position) {
        return position;
    }    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        ImageView iv_pic_item = null;
        if (convertView == null) {
            iv_pic_item = new ImageView(mContext);
            // 设置布局图片
            iv_pic_item.setLayoutParams(new GridView.LayoutParams(
                    mBitmapItemLists.get(position).getWidth(),
                    mBitmapItemLists.get(position).getHeight()));
            // 设置显示比例类型
            iv_pic_item.setScaleType(ImageView.ScaleType.FIT_CENTER);
        } else {
            iv_pic_item = (ImageView) convertView;
        }
        iv_pic_item.setImageBitmap(mBitmapItemLists.get(position));
        return iv_pic_item;
    }
}
public class GridPicListAdapter extends BaseAdapter {    // 映射List
    private List<Bitmap> picList;
    private Context context;    public GridPicListAdapter(Context context, List<Bitmap> picList) {
        this.context = context;
        this.picList = picList;
    }    @Override
    public int getCount() {
        return picList.size();
    }    @Override
    public Object getItem(int position) {
        return picList.get(position);
    }    @Override
    public long getItemId(int position) {
        return position;
    }    @Override
    public View getView(int position, View convertView, ViewGroup arg2) {
        ImageView iv_pic_item = null;
        int density = (int) SchemeUtils.getDensity(context);
        if (convertView == null) {
            iv_pic_item = new ImageView(context);
            // 设置布局图片
            iv_pic_item.setLayoutParams(new GridView.LayoutParams(
                    80 * density,
                    100 * density));
            // 设置显示比例类型
            iv_pic_item.setScaleType(ImageView.ScaleType.FIT_XY);
        } else {
            iv_pic_item = (ImageView) convertView;
        }
        iv_pic_item.setBackgroundColor(Color.BLACK);
        iv_pic_item.setImageBitmap(picList.get(position));
        return iv_pic_item;
    }
}这两个是适配器
是主要负责适配什么的。主要是做什么的...我周六答辩了就  好惶恐

这2个都只是展示图片的
主要给你讲getView方法吧：
GridView会调用getView方法来获得一个view展示到ui上
position：要展示的位置，convertView：可以被重复利用（复用）的view，ViewGroup：父容器（getView返回时会自己add，此处不需要再add）
if（convertView==null）如果没有可复用的view当然要自己创建一个了，有的话就直接拿来用
iv_pic_item.setLayoutParams设置子布局的属性，第一个adapter表示宽高是bitmap的宽高，第二个表示固定80dp*100dp
iv_pic_item.setScaleType设置显示模式，此处为拉伸铺满，其他属性自行查找
iv_pic_item.setImageBitmap设置一张图片
iv_pic_item.setBackgroundColor设置背景颜色
return返回给GridView，gv会将这个view放到对应的位置两个adapter都存在存在的问题：item的宽高这样写不太好，想改有点麻烦...

那哥哥，这个判断条件是为了防止什么，或者说为了去判断什么可能的，没有这个判断会怎么样。
因为后面的blank-position=1这个方法可以判断是否在两边了啊，可以判断在同一行啊。

原来还是那个拼团的功能啊举个例子：每行有10个，问你position=9和10是不是一行？所以就有了if（是同一行&&相差1）

调试易

一个基于android的拼图游戏问题。希望有人帮我改进

解决方案 »