Android 将上下文传递给处理程序

是否可以将参数传递给Android处理程序？？我有两段代码

new Thread(){
        public void run(){
            for(;;){
                uiCallback.sendEmptyMessage(0);
                Thread.sleep(2000); //sleep for 2 seconds
            }
        }
    }.start();


    private Handler uiCallback = new Handler(){
    public void handleMessage(Message msg){
        //add a new blossom to the blossom ArrayList!!
        blossomArrayList.add(new Blossom(context, R.drawable.blossom));
    }
};

我当然会得到一个错误，因为处理程序方法无法看到我的上下文。这可能是因为这段代码

public BoardView(Context context){
    super(context);

上下文在其他地方不可见，我想知道是否可以将它作为参数传递给我的处理程序

编辑：我发布了两段主要代码来回答一个关于为什么我的Blossom对象需要上下文的问题。我自己也不是100%确定>>也许你可以看看，看看发生了什么事

public class Blossom{
private Bitmap blossom;
private float blossomX = 0;
private float blossomY = 0;
private Random generator = new Random();

public Blossom(Context context, int drawable)
{
    blossom = BitmapFactory.decodeResource(context.getResources(), drawable); 
    blossomX = generator.nextInt(300);
}

public Bitmap getBitmap()
{
    return blossom;
}

public float getBlossomX()
{
    return blossomX;
}

public float getBlossomY()
{
    return blossomY;
}

public void Fall(Canvas canvas, float boxY)
{
    //draws the flower falling
    canvas.drawBitmap(blossom, blossomX,
            blossomY = blossomY+3 , null);

    //collision detection, currently not working after 
    //implementing random start location

    //if(blossomY + 29 == boxY)
    //{
        //canvas.drawBitmap(blossom,0,0,null);
    //}

}
}


public class BoardView extends SurfaceView implements SurfaceHolder.Callback{
Context mContext;

Bitmap box = 
    (BitmapFactory.decodeResource
            (getResources(), R.drawable.box));

private BoardThread thread;
private float box_x = 140;
private float box_y = 378;
private float boxWidth = box.getWidth();
private float boxHeight = box.getHeight();
private ArrayList<Blossom> blossomArrayList = new ArrayList<Blossom>();;

boolean mode = false;

RectF boxRect = new RectF(box_x,box_y, box_x + boxWidth, box_y + boxHeight);

public BoardView(Context context){
    super(context);

    //surfaceHolder provides canvas that we draw on
    getHolder().addCallback(this);

    // controls drawings
    thread = new BoardThread(getHolder(),this);

    //pass variables to instance of Blossom
    //for(int i = 0; i <= 3; i++)
    //{
        //blossomArrayList.add(new Blossom(context, R.drawable.blossom));
    //}

    new Thread(){
        public void run(){
            for(;;){
                uiCallback.sendEmptyMessage(0);
                Thread.sleep(2000); //sleep for 2 seconds
            }
        }
    }.start();

    //intercepts touch events
    setFocusable(true);

}

@Override

public void onDraw(Canvas canvas){
    canvas.drawColor(Color.WHITE);  


    //draw box and set start location
    canvas.drawBitmap(box, box_x - (boxWidth/2), 
            box_y - (boxHeight/2), null);

    for(int i = 0; i<= 3; i++)
    {
        blossomArrayList.get(i).Fall(canvas, box_y);
    }

}

@Override
public boolean onTouchEvent(MotionEvent event){

    if(event.getAction() == MotionEvent.ACTION_DOWN){
        if(boxRect.contains(event.getX(),event.getY())){
            mode = true;
        }
    }

    if(event.getAction() == MotionEvent.ACTION_MOVE) {
        if(boxRect.contains(event.getX(),event.getY())){
            mode = true;
        }
        if(mode == true){
            box_x = (int)event.getX();
            boxRect.set(box_x,box_y, box_x + boxWidth, box_y + boxHeight);
        }

    }

    if(event.getAction() == MotionEvent.ACTION_UP){
        mode = false;
    }

    invalidate();

    return true;
}

@Override
public void surfaceChanged(SurfaceHolder holder, 
        int format, int width, int height ){

}

@Override
public void surfaceCreated(SurfaceHolder holder){
    thread.startRunning(true);
    thread.start();
}

@Override
public void surfaceDestroyed(SurfaceHolder holder){
    thread.startRunning(false);
    thread.stop();
}

private Handler uiCallback = new Handler(){
    public void handleMessage(Message msg){
        //add a new blossom to the blossom ArrayList!!
        blossomArrayList.add(new Blossom(context, R.drawable.blossom));
    }
};


}

公共类{
私家车；
专用浮点数x=0；
私有float flowery=0；
专用随机生成器=新随机（）；
public Blossom（上下文，int可绘制）
{
blossom=BitmapFactory.decodeResource（context.getResources（），可绘制）；
Bloomax=发电机下一个（300）；
}
公共位图getBitmap（）
{
返花；
}
公共浮点数getflowerx（）
{
返花；
}
公众花车
{
返璞归真；
}
公共空旷瀑布（帆布、浮箱）
{
//引来落花
画布.绘图位图（blossom，blossom X，
flowery=flowery+3，空）；
//碰撞检测，当前不工作后
//实现随机起始位置
//如果（花朵状+29==方形）
//{
//drawBitmap（blossom，0,0，null）；
//}
}
}
公共类BoardView扩展了SurfaceView，实现了SurfaceHolder.Callback{
语境；
位图框=
（BitmapFactory.decodeResource）
（getResources（），R.drawable.box））；
专用板线；
专用浮箱_x=140；
专用浮箱_y=378；
私有float-boxWidth=box.getWidth（）；
私有float-boxHeight=box.getHeight（）；
private ArrayList FlowerArrayList=新建ArrayList（）；；
布尔模式=假；
RectF-boxRect=新的RectF（长方体x，长方体y，长方体x+长方体宽度，长方体y+长方体高度）；
公共BoardView（上下文）{
超级（上下文）；
//surfaceHolder提供了我们绘制的画布
getHolder（）.addCallback（此）；
//控制图形
thread=新的BoardThread（getHolder（），this）；
//将变量传递给Blossom的实例
//对于（inti=0；i来说，如果您创建一个扩展处理程序的子类会怎么样？这样您就可以传递任何想要的参数

但出于好奇，为什么Blossom对象需要上下文对象？通常最好将逻辑与GUI依赖项分开。
创建一个扩展处理程序的类，并存储对上下文的弱引用。这将有助于防止一些内存问题

public class SomeHandler extends Handler {

    // A weak reference to the enclosing context
    private WeakReference<Context> mContext;

    public SomeHandler (Context context) {
        mContext = new WeakReference<Context>(context);
    }

    public void handleMessage(Message msg) {

        // Get an actual reference to the DownloadActivity
        // from the WeakReference.
        Context context=mContext.get();
        ...
    }
}

公共类SomeHandler扩展了Handler{
//对封闭上下文的弱引用
私有WeakReference mContext；
公共SomeHandler（上下文）{
mContext=新的WeakReference（上下文）；
}
公共无效handleMessage（消息消息消息）{
//获取对DownloadActivity的实际引用
//来自WeakReference。
Context=mContext.get（）；
...
}
}
我已经发布了我的其余代码，以便您可以看到上下文发生了什么。我真的不知道：（这是我唯一能弄明白如何将位图放入Blossom类的方法，这就是为什么。你的Blossom构造函数可以只取位图。但是，你想要的是，只需创建一个新类，比如MyHandler，它扩展了Handler，并创建一个构造函数公共MyHandler（上下文上下文）{……}谢谢你-我刚把位图传给它，它很好：D为什么我不先这样做…非常有用。非常感谢。