Android-Set auf Drag Listener zeigt Fehler

Question

Ich entwickle eine Android-App mit Drag & Drop. Und ich benutze auch einen Rundfunkempfänger für den Bildschirm. Als ich setOnDragListener verwende Es zeigt einen Fehler:

java.lang.RuntimeException: Error receiving broadcast Intent { act=init view flg=0x10 } in com.app.lockscreenlibrary.LockBroadcastReceiver@f22ed7d 

Kann bitte jemand mir helfen, das Problem zu lösen? Hier ist mein Code:

ActivityView.java

public class ActivityView extends FrameLayout { 

public LinearLayout drop; 
TextView text,sucess; 
int total , failure = 0; 
ImageView viewDrop; 

private GestureDetector gestureDetector; 

private Context mContext; 

Button btnUnlock; 


Button btn1; 

private int CLICK_ACTION_THRESHHOLD = 200; 
private float startX; 
private float startY; 


public ActivityView(Context context) { 
this(context, null); 
} 

public ActivityView(Context context, AttributeSet attrs) { 
this(context, attrs, 0); 
} 

public ActivityView(Context context, AttributeSet attrs, int defStyleAttr) { 
super(context, attrs, defStyleAttr); 

init(context); 

} 

private void init(final Context context) { 
mContext = context; 
View view = inflate(context,R.layout.activity_view,null); 

gestureDetector = new GestureDetector(context, new SingleTapConfirm()); 

drop = (LinearLayout)findViewById(R.id.bottomlinear); 
sucess = (TextView)findViewById(R.id.Sucess); 

drop.setOnDragListener(); 

drop.setOnDragListener(new View.OnDragListener() { 
    @Override 
    public boolean onDrag(View v, DragEvent event) { 
    //return false; 

    final int action = event.getAction(); 
    switch(action) { 

     case DragEvent.ACTION_DRAG_STARTED: 
     break; 

     case DragEvent.ACTION_DRAG_EXITED: 
     break; 

     case DragEvent.ACTION_DRAG_ENTERED: 
     break; 

     case DragEvent.ACTION_DROP:{ 
     failure = failure+1; 
     return(true); 
     } 

     case DragEvent.ACTION_DRAG_ENDED:{ 
     total = total +1; 
     int suc = total - failure; 
     sucess.setText("Sucessful Drops :"+suc); 
     text.setText("Total Drops: "+total); 
     return(true); 

     } 

     default: 
     break; 
    } 

    return true; 
    } 
}); 


btnUnlock = (Button) view.findViewById(R.id.unlock); 

btnUnlock.setOnClickListener(new OnClickListener() { 
    @Override public void onClick(View v) { 
    LockHelper.getLockLayer().unlock(); 
    } 
}); 

btn01 = (Button) view.findViewById(R.id.btn0); 

btn1.setOnTouchListener(new View.OnTouchListener() { 

          @Override 
          public boolean onTouch(View v, MotionEvent event) { 

          Log.d("LockView", "onTouch"); 

          switch (event.getAction()) { 

           case MotionEvent.ACTION_DOWN: 
           startX = event.getX(); 
           startY = event.getY(); 
           break; 
           case MotionEvent.ACTION_UP: 
           float endX = event.getX(); 
           float endY = event.getY(); 
           if (isAClick(startX, endX, startY, endY)) { 
            Log.d("LockView", "clicked"); 
           } else { 

           } 
           break; 
          } 
          v.getParent().requestDisallowInterceptTouchEvent(true); //specific to my project 
          return false; 



          } 
         }); 




     addView(view); 
} 

} 
} 

private class SingleTapConfirm extends GestureDetector.SimpleOnGestureListener { 

@Override 
public boolean onSingleTapUp(MotionEvent event) { 
    Log.d("LockView", "clicked1"); 
    return true; 
} 

} 

private boolean isAClick(float startX, float endX, float startY, float endY) { 
float differenceX = Math.abs(startX - endX); 
float differenceY = Math.abs(startY - endY); 
if (differenceX > CLICK_ACTION_THRESHHOLD/* =5 */ || differenceY > CLICK_ACTION_THRESHHOLD) { 
    return false; 
} 
return true; 
} 
} 

LockBroadcastReceiver.java

final public class LockBroadcastReceiver extends BroadcastReceiver { 
private static final String TAG = LockBroadcastReceiver.class.getSimpleName(); 

private volatile boolean bInterruptSupervisor = false; 

private ScheduledThreadPoolExecutor mExecutor; 
private FutureRunnable mSupervisorRunnable; 

private static final int SCHEDULE_TASK_NUMBER = 3; 

private PhoneStateChange mPhoneStateChangeCallback; 

public void assignPhoneStateChangeCallback(PhoneStateChange phoneStateChangeCallback) { 
mPhoneStateChangeCallback = phoneStateChangeCallback; 
} 

@Override public void onReceive(Context context, Intent intent) { 
String mAction = intent.getAction(); 

//DU.sd("broadcast -----The Intent Action is: ", "" + mAction); 

switch (mAction) { 
    case LockHelper.INIT_VIEW_FILTER: 
    LockHelper.INSTANCE.initLockViewInBackground(context); 
    break; 
    case Intent.ACTION_SCREEN_ON: 
    refreshBatteryInfo(); 
    bringLockViewBackTopIfNot(); 
    break; 
    case CoreIntent.ACTION_SCREEN_LOCKER_UNLOCK: 
    shutdownScheduleExecutor(); 
    break; 
    case LockHelper.START_SUPERVISE: 
    bInterruptSupervisor = false; 
    supervise(context.getApplicationContext()); 
    break; 
    case LockHelper.STOP_SUPERVISE: 
    bInterruptSupervisor = true; 
    break; 
    case LockHelper.SHOW_SCREEN_LOCKER: 
    //DU.sd("broadcast", "locker received"); 
    case Intent.ACTION_SCREEN_OFF: 
    LockHelper.INSTANCE.initialize(context); 
    LockHelper.INSTANCE.getLockLayer().lock(); 
    bInterruptSupervisor = true; 
    break; 
    case Intent.ACTION_POWER_CONNECTED: 
    //LockHelper.INSTANCE.getLockView().batteryChargingAnim(); 
    break; 
    case Intent.ACTION_POWER_DISCONNECTED: 
    //LockHelper.INSTANCE.getLockView().batteryChargingAnim(); 
    break; 
    case Intent.ACTION_SHUTDOWN: 
    break; 
    case "android.intent.action.PHONE_STATE": 
    TelephonyManager tm = 
     (TelephonyManager) context.getSystemService(Service.TELEPHONY_SERVICE); 

    switch (tm.getCallState()) { 
     case TelephonyManager.CALL_STATE_RINGING: 
     mPhoneStateChangeCallback.ringing(); 
     Log.i(TAG, "RINGING :" + intent.getStringExtra("incoming_number")); 
     break; 
     case TelephonyManager.CALL_STATE_OFFHOOK: 
     mPhoneStateChangeCallback.offHook(); 
     //DU.sd(TAG, "off hook"); 
     break; 
     case TelephonyManager.CALL_STATE_IDLE: 
     mPhoneStateChangeCallback.idle(); 
     Log.i(TAG, "incoming IDLE"); 
     break; 
    } 
    break; 
    default: 
    break; 
} 
} 

abstract class FutureRunnable implements Runnable { 

private Future<?> future; 

public Future<?> getFuture() { 
    return future; 
} 

public void setFuture(Future<?> future) { 
    this.future = future; 
} 
} 

public void supervise(final Context context) { 
//DU.sd("service", "supervise"); 

initScheduleExecutor(); 

if (mSupervisorRunnable == null) { 
    mSupervisorRunnable = new FutureRunnable() { 
    public void run() { 
     if (bInterruptSupervisor) getFuture().cancel(true); 

     boolean cameraRunning = false; 
     Camera _camera = null; 
     try { 
     _camera = Camera.open(); 
     cameraRunning = _camera == null; 
     } catch (Exception e) { 
     // fail to open camera, secure to ignore exception 
     //DU.sd("camera exception on supervise"); 
     cameraRunning = true; 
     } finally { 
     if (_camera != null) { 
      _camera.release(); 
      getFuture().cancel(true); 
      context.sendBroadcast(new Intent(LockHelper.SHOW_SCREEN_LOCKER)); 
     } 
     } 

     if (!cameraRunning) context.sendBroadcast(new Intent(LockHelper.SHOW_SCREEN_LOCKER)); 
    } 
    }; 
} 
Future<?> future = 
    mExecutor.scheduleAtFixedRate(mSupervisorRunnable, 2000, 500, TimeUnit.MILLISECONDS); 
mSupervisorRunnable.setFuture(future); 
} 

private void bringLockViewBackTopIfNot() { 
initScheduleExecutor(); 
mExecutor.scheduleAtFixedRate(new Runnable() { 
    @Override public void run() { 
    LockHelper.INSTANCE.getLockLayer().requestFullScreen(); 
    } 
}, 1000, 1000, TimeUnit.MILLISECONDS); 
} 

private void refreshBatteryInfo() { 
initScheduleExecutor(); 
mExecutor.scheduleAtFixedRate(new Runnable() { 
    @Override public void run() { 
    //LockHelper.INSTANCE.getLockView().refreshBattery(); 
    } 
}, 2, 2, TimeUnit.MINUTES); 
} 

private void initScheduleExecutor() { 
if (mExecutor == null) { 
    synchronized (this) { 
    if (mExecutor == null) mExecutor = new ScheduledThreadPoolExecutor(SCHEDULE_TASK_NUMBER); 
    } 
} 
} 

public synchronized void shutdownScheduleExecutor() { 
if (mExecutor == null) return; 

mExecutor.shutdown(); 
mExecutor = null; 
} 
} 

LockHelper.java

public enum LockHelper implements SwipeEvent { 
INSTANCE; 
private static Context mContext; 

private final int UNLOCK = 830; 
private final int UNLOCK_WITH_PASSWORD = 831; 
private final int SWITCH_TO_GUEST = 345; 

public static final String INIT_VIEW_FILTER = "init view"; 
public static final String START_SUPERVISE = "start supervise"; 
public static final String STOP_SUPERVISE = "stop supervise"; 
public static final String SHOW_SCREEN_LOCKER = "show screen locker"; 

private static LockView mLockView; 
private static LockLayer mLockLayer; 

public void initialize(Context context) { 
    initContextViewAndLayer(context); 

    loadLockView(context); 
} 
/** 
* @throws NullPointerException if not init 
*/ 
public static LockView getLockView() { 
    if (mLockView == null) 
     throw new NullPointerException("init first"); 
    return mLockView; 
} 

/** 
* @throws NullPointerException if not init 
*/ 
public static LockLayer getLockLayer() { 
    if (mLockLayer == null) 
     throw new NullPointerException("init first"); 

    return mLockLayer; 
} 

/** 
* @throws NullPointerException if context == null 
*/ 
public void initLockViewInBackground(final Context context) { 
    if (context == null) 
     throw new NullPointerException("context == null, assign first"); 

    if (mLockView == null || mLockLayer == null) 
     initContextViewAndLayer(context); 
} 

public void initContextViewAndLayer(Context context) { 
    if (mContext == null) 
     synchronized (this) { 
      if (mContext == null) 
       mContext = context; 


     } 

    //init layout view 
    if (mLockView == null) 
     synchronized (this) { 
      if (mLockView == null) 
       mLockView = new LockView(context); 
     } 

    //init lock layer 
    if (mLockLayer == null) 
     synchronized (this) { 
      if (mLockLayer == null) 
       mLockLayer = LockLayer.getInstance(context, mLockView); 
     } 
} 

private volatile boolean mIsInitialized = false; 

public void loadLockView(Context context) { 
    mLockView.showLockHome(); 

    if(!mIsInitialized){ 
     //mLockView.assignSwipeEvent(this); 
     // 
     //mLockView.assignDirectionOperator(new SwipeWithAnimListener.DirectionOperator() { 
     // @Override 
     // public void up() { 
     // } 
     // 
     // @Override 
     // public void down() { 
     // 
     // } 
     // 
     // @Override 
     // public void left() { 
     //  if(!mLockView.leftSlidable()) return; 
     // 
     //  mHandler.sendEmptyMessage(UNLOCK); 
     // } 
     // 
     // @Override 
     // public void right() { 
     //  if(!mLockView.rightSlidable()) return; 
     // 
     //  mHandler.sendEmptyMessage(UNLOCK); 
     // } 
     //}); 

//   mLockView.assignPinCodeRuler(new PinCodeView.UnlockInterface() { 
//    @Override 
//    public void onUnlock(String password) { 
// 
//     Message msg = new Message(); 
//     msg.what = UNLOCK_WITH_PASSWORD; 
//     msg.obj = password; 
//     mHandler.sendMessage(msg); 
//    } 
// 
//    @Override 
//    public void onBack() { 
//     mLockView.switchBackToCenterFromBottom(); 
//    } 
//   }); 

     mIsInitialized = true; 
    } 

    mLockLayer.lock(); 
    showLockLayer(); 
} 

private Handler mHandler = new Handler(Looper.getMainLooper()) { 
    @Override 
    public void handleMessage(Message msg) { 

     switch (msg.what) { 
      case UNLOCK: 
       //DU.sd("handler", "unlock"); 

       unlock(); 
       break; 

      case UNLOCK_WITH_PASSWORD: 

       if (!(msg.obj instanceof String)) break; 
       String password = (String) msg.obj; 
       switchUserIfExistOrAlertUser(password); 

       break; 

      default: 
       break; 
     } 
    } 
}; 

private void unlock() { 
    mLockLayer.unlock(); 
    //mLockView.stopShimmer(); 

    mContext.sendBroadcast(new Intent(LockHelper.STOP_SUPERVISE)); 


    mContext.sendBroadcast(new Intent(CoreIntent.ACTION_SCREEN_LOCKER_UNLOCK)); 
} 

private void switchUserIfExistOrAlertUser(String password) { 
    if (TextUtils.isEmpty(password)) { 
     wrong(); 
     return; 
    } 

    if (!password.equals("1234")) { 
     wrong(); 
     return; 
    } 

    unlockScreenAndResetPinCode(); 
} 
private void unlockScreenAndResetPinCode() { 
    unlock(); 
//  mLockView.resetPinCodeView(); 
} 

private void wrong() { 

} 


public static final String INTENT_KEY_WITH_SECURE = "with_secure"; 

@Override 
public <S, T> void onSwipe(S s, T t) { 


    mHandler.postDelayed(new Runnable() { 
     @Override 
     public void run() { 
      LockHelper.INSTANCE.getLockLayer().removeLockView(); 
     } 
    }, 1000); 

    //triggerCameraWithSecure(mContext, !(t instanceof Boolean) || (Boolean) t); 
} 

private void triggerCameraWithSecure(Context context, boolean withSecure) { 
    //if (!CameraHelper.hasCameraHardware(context)) return; 
    // 
    //try { 
    // CameraHelper.cameraStrategy(context, withSecure); 
    //} catch (Exception e) { 
    // // may cannot open 
    // e.printStackTrace(); 
    // showLockLayer(); 
    //} 
    // 
    //context.sendBroadcast(new Intent(LockHelper.START_SUPERVISE)); 
} 


private void showLockLayer() { 

    mLockView.showLockHome(); 
    mLockLayer.bringBackLockView(); 
} 

public void vibrate(long milliseconds) { 
    if (mContext == null) return; 
    Vibrator v = (Vibrator) mContext.getSystemService(Context.VIBRATOR_SERVICE); 
    // Vibrate for 500 milliseconds 
    v.vibrate(milliseconds == 0 ? 500 : milliseconds); 
} 

} 

Answer 1

Es gibt kein Problem mit dem Boradcast-Empfänger an sich. Sie haben eine klare Ausnahme im Code

java.lang.ClassCastException: com.happiness.lockscreenlibrary.LockScreenService cannot be cast to android.view.View$OnDragListener at 

Sie versuchen, eine nicht kompatible Klassentyp in einen anderen zu werfen. Ich konnte diesen Teil des Codes in dem, was Sie hier eingefügt haben, nicht sehen. Also, bitte versuchen Sie das herauszufinden. Im Grunde hat der Code, den Sie beim Empfangen der Sendung ausführen, einen Fehler, nichts mit dem Empfänger als solcher