Почему не отрисовывается картинка?

public class MainView extends SurfaceView implements SurfaceHolder.Callback {
 
    private MainThread mMainThread;
    private Hero mHero;
 
    public MainView(Context context) {
        super(context);
        init(null, 0);
    }
 
    private void init(AttributeSet attrs, int defStyle) {
        // добавляем этот класс, как содержащий функцию обратного вызова
        // для взаимодействия с событиями
        getHolder().addCallback(this);
 
        mHero = new Hero(
                BitmapFactory.decodeResource(getResources(), R.drawable.moving_Hero)
                , 10, 50// начальное положение
                , 80, 80// ширина и высота спрайта
                , 25, 12);// FPS и число кадров в анимации
 
        // делаем MainView.focusable, чтобы оно могло обрабатывать события
        setFocusable(true);
 
        // создаём основной поток
        mMainThread = new MainThread(this);
    }
 
    public void update(){
        mHero.update();
    }
 
    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        canvas.drawColor(Color.WHITE);
 
        mHero.draw(canvas);
////////////////////
        // TODO: consider storing these as member variables to reduce
        // allocations per draw cycle.
        int paddingLeft = getPaddingLeft();
        int paddingTop = getPaddingTop();
        int paddingRight = getPaddingRight();
        int paddingBottom = getPaddingBottom();
 
        int contentWidth = getWidth() - paddingLeft - paddingRight;
        int contentHeight = getHeight() - paddingTop - paddingBottom;
        ////////////////////////
        canvas.restore();
    }
 
    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        Canvas canvas = null;
        SurfaceHolder surfaceHolder = getHolder();
        mMainThread.setRunning(true);
        mMainThread.start();
        try {
            // получаем объект Canvas и выполняем отрисовку
            canvas = surfaceHolder.lockCanvas();
            synchronized (surfaceHolder) {
                canvas.drawColor(Color.WHITE);
                mHero.draw(canvas);
            }
        } finally {
            if (canvas != null) {
                // отрисовка выполнена. выводим результат на экран
                surfaceHolder.unlockCanvasAndPost(canvas);
            }
        }
    }
 
    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
        //mMainThread.setRunning(false);
    }
 
    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
    //посылаем потоку команду на закрытие и дожидаемся,
    //пока поток не будет закрыт.
        boolean retry = true;
        while (retry) {
            try {
                    mMainThread.join();
                    retry = false;
            } catch (InterruptedException e) {
                 // пытаемся снова остановить поток thread
            }
        }
   }
}

public class MainThread extends Thread {
    // признак того, что игра запущена
    private boolean running;
    private MainView mMainView;
    private SurfaceHolder mSurfaceHolder;
 
    MainThread(MainView mMainView) {
        // вызываем базовый конструктор
        super();
 
        // настраиваем члены класса
        this.mMainView = mMainView;
        mSurfaceHolder = mMainView.getHolder();
    }
 
    public void setRunning(boolean running){
        this.running = running;
    }
 
    @Override public void run(){
        Canvas canvas;
        while(running){
            canvas = null;
            // пытаемся заблокировать canvas
            // для изменение картинки на поверхности
            try{
                canvas = mSurfaceHolder.lockCanvas();
                synchronized(mSurfaceHolder){
                    // здесь будет обновляться состояние игры
                    // и формироваться кадр для вывода на экран
                    this.mMainView.draw(canvas);//Вызываем метод для рисования
                    sleep(10);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally{
                // в случае ошибки, плоскость не перешла в
                //требуемое состояние
                if(canvas!= null){
                    mSurfaceHolder.unlockCanvasAndPost(canvas);
                }
            }
        }
    }
}

import android.app.ActionBar;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Rect;
import android.util.AttributeSet;
 
// режимы движения героя
enum HeroMode {
    UNDEFINED,      // не опредён
    STEP,           // шаг
    RUN,            // бег
    JUMP_UP,        // начало прыжка
    JUMP_FLY,       // полёт в прыжке
    JUMP_DOWN,      // окончание прыжка
    FALL_BACK,      // падаение назад
    FALL_FORWARD    // падение вперёд
}
 
public class Hero {
    private static final String TAG = Hero.class.getSimpleName();
 
    private Bitmap mBitmap;     // Картинка с анимационной последовательностью
    private Rect mSourceRect;   // Прямоугольная область в bitmap, которую нужно нарисовать
    private Rect mDestRect;     // Прямоугольная область в bitmap, которую нужно нарисовать
    private int mFramesCnt;     // Число кадров в анимации
    private int mCurrentFrameNo;// Текущий кадр
    private long frameTicker;   // время обновления последнего кадра
    private int framePeriod;    // сколько миллисекунд должно пройти перед сменой кадра (1000/fps)
 
    private HeroMode mHeroMode = HeroMode.STEP;
 
    private int mSpriteWidth;// ширина спрайта (одного кадра)
    private int mSpriteHeight;// высота спрайта
 
    private int mX;// X координата спрайта (верхний левый угол картинки)
    private int mY;// Y координата спрайта (верхний левый угол картинки)
 
    public Hero(Context context, AttributeSet attrs) {}
 
    public Hero(Bitmap bitmap, int x, int y, int width, int height, int fps, int frameCount) {
        ActionBar.LayoutParams layoutParams = new ActionBar.LayoutParams(175, 105);
        this.mBitmap = bitmap;
        this.mX = x;
        this.mY = y;
        mCurrentFrameNo = 0;
        mFramesCnt = frameCount;
        mSpriteWidth = width;
        mSpriteHeight = height;
        mSourceRect = new Rect(0, 0, mSpriteWidth, mSpriteHeight);
        framePeriod = 1000 / fps;
        frameTicker = 0l;
    }
 
    public void draw(Canvas canvas) {
        //комманда вывода рисунка на экран.
        canvas.drawBitmap(mBitmap, mSourceRect, mDestRect, null);
    }
 
    public void update() {
        mCurrentFrameNo++;
 
        switch (mHeroMode) {
            case STEP: {
                // TODO: отобразить героя, идущего шагом
            }
            break;
            case RUN: {
                // TODO: отобразить бегущего героя
            }
            break;
            case JUMP_UP: {
                // TODO: отобразить начало прыжка
            }
            break;
            case JUMP_FLY:
            {
                // TODO отобразить героя в полёте
            }
            break;
            case JUMP_DOWN:{
                // TODO: отобразить спускающегося героя
            }
            break;
            case FALL_BACK:{
                // TODO: отобразить героя, падающего назад
            }
            break;
            case FALL_FORWARD:{
                // TODO: отобразить героя, падающего вперёд
            }
            break;
            default: {
                // TODO отобразить стоящего героя
            }
        }
    }
}
}