2016-02-06 54 views
7

मुझे वेबकैम से कनेक्ट करने के आधार पर एक एंड्रॉइड एप्लिकेशन बनाया गया था। वेबकैम के साथ कनेक्शन के दौरान आवेदन आकर्षण काम करता है। लेकिन जब मैं अनप्लग करता हूं, तो मेरा मोबाइल एप्लिकेशन क्रैश हो जाता है और दिखाता है कि "दुर्भाग्यवश एप्लिकेशन को इसके काम को रोक दिया गया था"।यूएसबी वेब कैम के साथ एंड्रॉइड में अनप्लग यूएसबी केबल त्रुटि को कैसे ठीक करें?

वीडियो गतिविधि:

public class VideoActivity extends AppCompatActivity { 
ActionBar actionBar; 


public static int mCurrentPosition = -1; 
private Handler handler; 
private Runnable mRunnable; 

//-------------------------------- 
private static final boolean DEBUG = true; 
private static final String TAG = "VIDEO ACTIVITY"; 


private static final int DEFAULT_WIDTH = 640; //640 
private static final int DEFAULT_HEIGHT = 480; //480 

private USBMonitor mUSBMonitor; 
private ICameraClient mCameraClient; 

private CameraViewInterface mCameraView; 

private boolean isSubView; 


@Override 
protected void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    setContentView(R.layout.new_video_layout); 

    if (mUSBMonitor == null) { 
     mUSBMonitor = new USBMonitor(getApplicationContext(), mOnDeviceConnectListener); 
     final List<DeviceFilter> filters = DeviceFilter.getDeviceFilters(getApplicationContext(), R.xml.device_filter); 
     mUSBMonitor.setDeviceFilter(filters); 
    } 
    if (savedInstanceState != null) { 
     mCurrentPosition = savedInstanceState.getInt("STATE"); 
    } 

    actionBar = getSupportActionBar(); 
    assert actionBar != null; 
    actionBar.setDisplayShowCustomEnabled(true); 
    actionBar.setBackgroundDrawable(new ColorDrawable(Color.WHITE)); 
    actionBar.setDisplayShowTitleEnabled(false); 
    actionBar.setDisplayShowHomeEnabled(false); 

    LayoutInflater inflator = (LayoutInflater) this.getSystemService(Context.LAYOUT_INFLATER_SERVICE); 
    View v = inflator.inflate(R.layout.custom_actionbar, null); 
    actionBar.setCustomView(v); 



    mCameraView = (CameraViewInterface) findViewById(R.id.camera_view); 
    mCameraView.setAspectRatio(DEFAULT_WIDTH/(float) DEFAULT_HEIGHT); 
     mCameraView.setCallback(mCallback); 
} 

@Override 
public void onBackPressed() { 
    finish(); 
    moveTaskToBack(true); 
    super.onBackPressed(); 
} 


private final USBMonitor.OnDeviceConnectListener mOnDeviceConnectListener = new USBMonitor.OnDeviceConnectListener() { 
    @Override 
    public void onAttach(final UsbDevice device) { 
     if (DEBUG) Log.v(TAG, "OnDeviceConnectListener#onAttach:"); 
     if (!updateCameraDialog() && (mCameraView.getSurface() != null)) { 
      tryOpenUVCCamera(true); 
     } 
    } 

    @Override 
    public void onConnect(final UsbDevice device, final USBMonitor.UsbControlBlock ctrlBlock, final boolean createNew) { 
     if (DEBUG) Log.v(TAG, "OnDeviceConnectListener#onConnect:"); 
    } 

    @Override 
    public void onDisconnect(final UsbDevice device, final USBMonitor.UsbControlBlock ctrlBlock) { 
     if (DEBUG) Log.v(TAG, "OnDeviceConnectListener#onDisconnect:"); 
    } 

    @Override 
    public void onDettach(final UsbDevice device) { 
     if (DEBUG) Log.v(TAG, "OnDeviceConnectListener#onDettach:"); 
     if (mCameraClient != null) { 
      mCameraClient.disconnect(); 
      mCameraClient.release(); 
      mCameraClient = null; 
     } 
     updateCameraDialog(); 
    } 

    @Override 
    public void onCancel() { 
     if (DEBUG) Log.v(TAG, "OnDeviceConnectListener#onCancel:"); 

    } 
}; 

private boolean updateCameraDialog() { 
    final Fragment fragment = getFragmentManager().findFragmentByTag("CameraDialog"); 
    if (fragment instanceof CameraDialog) { 
     ((CameraDialog) fragment).updateDevices(); 
     return true; 
    } 
    return false; 
} 

private void tryOpenUVCCamera(final boolean requestPermission) { 
    if (DEBUG) Log.v(TAG, "tryOpenUVCCamera:"); 
    openUVCCamera(0); 
} 

public void openUVCCamera(final int index) { 
    if (DEBUG) Log.v(TAG, "openUVCCamera:index=" + index); 
    if (!mUSBMonitor.isRegistered()) return; 
    final List<UsbDevice> list = mUSBMonitor.getDeviceList(); 
    if (list.size() > index) { 

     if (mCameraClient == null) 
      mCameraClient = new CameraClient(getApplicationContext(), mCameraListener); 
     mCameraClient.select(list.get(index)); 
     mCameraClient.resize(DEFAULT_WIDTH, DEFAULT_HEIGHT); 
     mCameraClient.connect(); 
    } 
} 

private final CameraViewInterface.Callback mCallback = new CameraViewInterface.Callback() { 
    @Override 
    public void onSurfaceCreated(final Surface surface) { 
     tryOpenUVCCamera(true); 
    } 

    @Override 
    public void onSurfaceChanged(final Surface surface, final int width, final int height) { 
    } 

    @Override 
    public void onSurfaceDestroy(final Surface surface) { 

    } 
}; 

private final ICameraClientCallback mCameraListener = new ICameraClientCallback() { 
    @Override 
    public void onConnect() { 
     if (DEBUG) Log.v(TAG, "onConnect:"); 
     mCameraClient.addSurface(mCameraView.getSurface(), false); 
     isSubView = true; 
    } 

    @Override 
    public void onDisconnect() { 
     if (DEBUG) Log.v(TAG, "onDisconnect:"); 

    } 
};} 

UVCCamera:

public class UVCService extends Service { 
private static final boolean DEBUG = true; 
private static final boolean checkConn = true; 
private static final String TAG = "UVCService"; 

private USBMonitor mUSBMonitor; 

public UVCService() { 
    if (DEBUG) Log.d(TAG, "Constructor:"); 
} 

@Override 
public void onCreate() { 
    super.onCreate(); 
    if (DEBUG) Log.d(TAG, "onCreate:"); 
    if (mUSBMonitor == null) { 
     mUSBMonitor = new USBMonitor(getApplicationContext(), mOnDeviceConnectListener); 
     mUSBMonitor.register(); 
    } 
} 

@Override 
public void onDestroy() { 
    if (DEBUG) Log.d(TAG, "onDestroy:"); 
    if (checkReleaseService()) { 
     if (mUSBMonitor != null) { 
      mUSBMonitor.unregister(); 
      mUSBMonitor = null; 
     } 
    } 
    super.onDestroy(); 
} 

@Override 
public IBinder onBind(final Intent intent) { 
    if (DEBUG) Log.d(TAG, "onBind:" + intent); 
    if (IUVCService.class.getName().equals(intent.getAction())) { 
     Log.i(TAG, "return mBasicBinder"); 
     return mBasicBinder; 
    } 
    if (IUVCSlaveService.class.getName().equals(intent.getAction())) { 
     Log.i(TAG, "return mSlaveBinder"); 
     return mSlaveBinder; 
    } 
    return null; 
} 

@Override 
public void onRebind(final Intent intent) { 
    if (DEBUG) 
     Log.d(TAG, "onRebind:" + intent); 
} 

@Override 
public boolean onUnbind(final Intent intent) { 
    if (DEBUG) 
     Log.d(TAG, "onUnbind:" + intent); 
    if (checkReleaseService()) { 
     mUSBMonitor.unregister(); 
     mUSBMonitor = null; 
    } 
    return true; 
} 

//******************************************************************************** 
private final OnDeviceConnectListener mOnDeviceConnectListener = new OnDeviceConnectListener() { 
    @Override 
    public void onAttach(final UsbDevice device) { 
     if (DEBUG) Log.d(TAG, "OnDeviceConnectListener#onAttach:"); 
    } 

    @Override 
    public void onConnect(final UsbDevice device, final UsbControlBlock ctrlBlock, final boolean createNew) { 
     if (DEBUG) Log.d(TAG, "OnDeviceConnectListener#onConnect:"); 

     final int key = device.hashCode(); 
     CameraServer service; 
     synchronized (sServiceSync) { 
      service = sCameraServers.get(key); 
      if (service == null) { 
       service = CameraServer.createServer(UVCService.this, ctrlBlock, device.getVendorId(), device.getProductId()); 
       sCameraServers.append(key, service); 
      } else { 
       Log.w(TAG, "service already exist before connection"); 
      } 
      sServiceSync.notifyAll(); 
     } 
    } 

    @Override 
    public void onDisconnect(final UsbDevice device, final UsbControlBlock ctrlBlock) { 
     if (DEBUG) Log.d(TAG, "OnDeviceConnectListener#onDisconnect:"); 
     if (!checkConn) { 
      processStopService(UVCService.TAG); 
     } 
     removeService(device); 


     /*if(!checkConn){this.stopService(new Intent(this, MyService.class));} 
     ;*/ 
    } 

    @Override 
    public void onDettach(final UsbDevice device) { 
     if (DEBUG) Log.d(TAG, "OnDeviceConnectListener#onDettach:"); 
     if (!checkConn) { 
      processStopService(UVCService.TAG); 
     } 
     removeService(device); 
    } 

    @Override 
    public void onCancel() { 
     if (DEBUG) Log.d(TAG, "OnDeviceConnectListener#onCancel:"); 
     synchronized (sServiceSync) { 
      sServiceSync.notifyAll(); 
     } 
    } 
}; 

// ====================================================================================== 

private void processStopService(final String tag) { 
    Intent intent = new Intent(getApplicationContext(), UVCService.class); 
    intent.addCategory(tag); 
    stopService(intent); 
} 

// ====================================================================================== 
private void removeService(final UsbDevice device) { 
    final int key = device.hashCode(); 
    synchronized (sServiceSync) { 
     final CameraServer service = sCameraServers.get(key); 
     if (service != null) 
      service.release(); 
     sCameraServers.remove(key); 
     sServiceSync.notifyAll(); 
    } 
    if (checkReleaseService()) { 
     if (mUSBMonitor != null) { 
      mUSBMonitor.unregister(); 
      mUSBMonitor = null; 
     } 
    } 
} 

//******************************************************************************** 
private static final Object sServiceSync = new Object(); 
private static final SparseArray<CameraServer> sCameraServers = new SparseArray<CameraServer>(); 

/** 
* get CameraService that has specific ID<br> 
* if zero is provided as ID, just return top of CameraServer instance(non-blocking method) if exists or null.<br> 
* if non-zero ID is provided, return specific CameraService if exist. block if not exists.<br> 
* return null if not exist matched specific ID<br> 
* 
* @param serviceId 
* @return 
*/ 
private static CameraServer getCameraServer(final int serviceId) { 
    synchronized (sServiceSync) { 
     CameraServer server = null; 
     if ((serviceId == 0) && (sCameraServers.size() > 0)) { 
      server = sCameraServers.valueAt(0); 
     } else { 
      server = sCameraServers.get(serviceId); 
      if (server == null) 
       try { 
        Log.i(TAG, "waitting for service is ready"); 
        sServiceSync.wait(); 
       } catch (final InterruptedException e) { 
       } 
      server = sCameraServers.get(serviceId); 
     } 
     return server; 
    } 
} 

/** 
* @return true if there are no camera connection 
*/ 
private static boolean checkReleaseService() { 
    CameraServer server = null; 
    synchronized (sServiceSync) { 
     final int n = sCameraServers.size(); 
     if (DEBUG) Log.d(TAG, "checkReleaseService:number of service=" + n); 
     for (int i = 0; i < n; i++) { 
      server = sCameraServers.valueAt(i); 
      Log.i(TAG, "checkReleaseService:server=" + server + ",isConnected=" + (server != null ? server.isConnected() : false)); 
      if (server != null && !server.isConnected()) { 
       sCameraServers.removeAt(i); 
       server.release(); 
      } 
     } 
     return sCameraServers.size() == 0; 
    } 
} 

//******************************************************************************** 
private final IUVCService.Stub mBasicBinder = new IUVCService.Stub() { 
    private IUVCServiceCallback mCallback; 

    @Override 
    public int select(final UsbDevice device, final IUVCServiceCallback callback) throws RemoteException { 
     if (DEBUG) 
      Log.d(TAG, "mBasicBinder#select:device=" + (device != null ? device.getDeviceName() : null)); 
     mCallback = callback; 
     final int serviceId = device.hashCode(); 
     CameraServer server = null; 
     synchronized (sServiceSync) { 
      server = sCameraServers.get(serviceId); 
      if (server == null) { 
       Log.i(TAG, "request permission"); 
       mUSBMonitor.requestPermission(device); 
       Log.i(TAG, "wait for getting permission"); 
       try { 
        sServiceSync.wait(); 
       } catch (final Exception e) { 
        Log.e(TAG, "connect:", e); 
       } 
       Log.i(TAG, "check service again"); 
       server = sCameraServers.get(serviceId); 
       if (server == null) { 
        throw new RuntimeException("failed to open USB device(has no permission)"); 
       } 
      } 
     } 
     if (server != null) { 
      Log.i(TAG, "success to get service:serviceId=" + serviceId); 
      server.registerCallback(callback); 
     } 
     return serviceId; 
    } 

    @Override 
    public void release(final int serviceId) throws RemoteException { 
     if (DEBUG) Log.d(TAG, "mBasicBinder#release:"); 
     synchronized (sServiceSync) { 
      final CameraServer server = sCameraServers.get(serviceId); 
      if (server != null) { 
       if (server.unregisterCallback(mCallback)) { 
        if (!server.isConnected()) { 
         sCameraServers.remove(serviceId); 
         if (server != null) { 
          server.release(); 
         } 
         final CameraServer srv = sCameraServers.get(serviceId); 
         Log.w(TAG, "srv=" + srv); 
        } 
       } 
      } 
     } 
     mCallback = null; 
    } 

    @Override 
    public boolean isSelected(final int serviceId) throws RemoteException { 
     return getCameraServer(serviceId) != null; 
    } 

    @Override 
    public void releaseAll() throws RemoteException { 
     if (DEBUG) Log.d(TAG, "mBasicBinder#releaseAll:"); 
     CameraServer server; 
     synchronized (sServiceSync) { 
      final int n = sCameraServers.size(); 
      for (int i = 0; i < n; i++) { 
       server = sCameraServers.valueAt(i); 
       sCameraServers.removeAt(i); 
       if (server != null) { 
        server.release(); 
       } 
      } 
     } 
    } 

    @Override 
    public void resize(final int serviceId, final int width, final int height) { 
     if (DEBUG) Log.d(TAG, "mBasicBinder#resize:"); 
     final CameraServer server = getCameraServer(serviceId); 
     if (server == null) { 
      throw new IllegalArgumentException("invalid serviceId"); 
     } 
     server.resize(width, height); 
    } 

    @Override 
    public void connect(final int serviceId) throws RemoteException { 
     if (DEBUG) Log.d(TAG, "mBasicBinder#connect:"); 
     final CameraServer server = getCameraServer(serviceId); 
     if (server == null) { 
      throw new IllegalArgumentException("invalid serviceId"); 
     } 
     server.connect(); 
    } 

    @Override 
    public void disconnect(final int serviceId) throws RemoteException { 
     if (DEBUG) Log.d(TAG, "mBasicBinder#disconnect:"); 
     final CameraServer server = getCameraServer(serviceId); 
     if (server == null) { 
      throw new IllegalArgumentException("invalid serviceId"); 
     } 
     server.disconnect(); 
    } 

    @Override 
    public boolean isConnected(final int serviceId) throws RemoteException { 
     final CameraServer server = getCameraServer(serviceId); 
     return (server != null) && server.isConnected(); 
    } 

    @Override 
    public void addSurface(final int serviceId, final int id_surface, final Surface surface, final boolean isRecordable) throws RemoteException { 
     if (DEBUG) 
      Log.d(TAG, "mBasicBinder#addSurface:id=" + id_surface + ",surface=" + surface); 
     final CameraServer server = getCameraServer(serviceId); 
     if (server != null) 
      server.addSurface(id_surface, surface, isRecordable, null); 
    } 

    @Override 
    public void removeSurface(final int serviceId, final int id_surface) throws RemoteException { 
     if (DEBUG) Log.d(TAG, "mBasicBinder#removeSurface:id=" + id_surface); 
     final CameraServer server = getCameraServer(serviceId); 
     if (server != null) 
      server.removeSurface(id_surface); 
    } 

    @Override 
    public boolean isRecording(final int serviceId) throws RemoteException { 
     final CameraServer server = getCameraServer(serviceId); 
     return server != null && server.isRecording(); 
    } 

    @Override 
    public void startRecording(final int serviceId) throws RemoteException { 
     if (DEBUG) Log.d(TAG, "mBasicBinder#startRecording:"); 
     final CameraServer server = getCameraServer(serviceId); 
     if ((server != null) && !server.isRecording()) { 
      server.startRecording(); 
     } 
    } 

    @Override 
    public void stopRecording(final int serviceId) throws RemoteException { 
     if (DEBUG) Log.d(TAG, "mBasicBinder#stopRecording:"); 
     final CameraServer server = getCameraServer(serviceId); 
     if ((server != null) && server.isRecording()) { 
      server.stopRecording(); 
     } 
    } 

    @Override 
    public void captureStillImage(final int serviceId, final String path) throws RemoteException { 
     if (DEBUG) Log.d(TAG, "mBasicBinder#captureStillImage:" + path); 
     final CameraServer server = getCameraServer(serviceId); 
     if (server != null) { 
      server.captureStill(path); 
     } 
    } 

}; 

//******************************************************************************** 
private final IUVCSlaveService.Stub mSlaveBinder = new IUVCSlaveService.Stub() { 
    @Override 
    public boolean isSelected(final int serviceID) throws RemoteException { 
     return getCameraServer(serviceID) != null; 
    } 

    @Override 
    public boolean isConnected(final int serviceID) throws RemoteException { 
     final CameraServer server = getCameraServer(serviceID); 
     return server != null ? server.isConnected() : false; 
    } 

    @Override 
    public void addSurface(final int serviceID, final int id_surface, final Surface surface, final boolean isRecordable, final IUVCServiceOnFrameAvailable callback) throws RemoteException { 
     if (DEBUG) 
      Log.d(TAG, "mSlaveBinder#addSurface:id=" + id_surface + ",surface=" + surface); 
     final CameraServer server = getCameraServer(serviceID); 
     if (server != null) { 
      server.addSurface(id_surface, surface, isRecordable, callback); 
     } else { 
      Log.e(TAG, "failed to get CameraServer:serviceID=" + serviceID); 
     } 
    } 

    @Override 
    public void removeSurface(final int serviceID, final int id_surface) throws RemoteException { 
     if (DEBUG) Log.d(TAG, "mSlaveBinder#removeSurface:id=" + id_surface); 
     final CameraServer server = getCameraServer(serviceID); 
     if (server != null) { 
      server.removeSurface(id_surface); 
     } else { 
      Log.e(TAG, "failed to get CameraServer:serviceID=" + serviceID); 
     } 
    } 
}; 

}

+0

क्या वह पूरा त्रुटि संदेश था? यूएसबी अनप्लग होने के बजाय आप क्या करना चाहते हैं? यहां एंड्रॉइड पर कई विशेषज्ञ हैं (मैं उनमें से एक नहीं हूं)। यदि आपको प्रश्न का उत्तर नहीं मिलता है, तो यह लिंक: [पूछे] में एक अच्छी प्रश्न में कौन सी जानकारी शामिल करना है, इस पर युक्तियां शामिल हैं। –

+0

स्टैक ट्रेस के बिना, कुछ भी नहीं कहा जा सकता है। कौन जानता है कि कारण क्या है। कोई भी जादू गोलियाँ नहीं है (वे?)। [प्रदान की गई जानकारी की तरह है, मुझे एक दुर्घटना हुई थी। मुझे पता है कि कार टूट गई है] :) –

उत्तर

3

आप शायद यकीन है कि अपने कार्यक्रम क्योंकि ध्यान में न आया त्रुटियों की दुर्घटना नहीं है बनाने के लिए कुछ कोशिश पकड़ बयान उपयोग करना चाहिए:

@Override 
public void onDettach(final UsbDevice device) { 
    if (DEBUG) Log.v(TAG, "OnDeviceConnectListener#onDettach:"); 
    try { 
     if (mCameraClient != null) { 
      mCameraClient.disconnect(); 
      mCameraClient.release(); 
      mCameraClient = null; 
     } 
     updateCameraDialog(); 
    } catch (Exception ex) { 
     Log.e("Exception occurred", ex); 
    } 
} 

आम तौर पर सभी अपवादों को पकड़ना बुरा अभ्यास है, इसलिए आपको यह जांचना चाहिए कि कौन सा अपवाद फेंक दिया गया है और अपवाद को बदलकर आप इस विशिष्ट अपवाद को पकड़ते हैं।

+0

मैं अपने एंड्रॉइड एप्लिकेशन में यूवीसी वेबकैम को जोड़ रहा था और चला रहा था। उपर्युक्त कोड मेरी त्रुटि को सुधार नहीं पाएगा। मैं अपना कोड अपडेट करता हूं जिसमें सभी कैमरा संबंधित कनेक्ट और डिस्कनेक्ट विकल्पों को ले जाने के लिए सेवा शामिल है। –

+0

फिर क्या आप क्रैश का कारण बनने वाली त्रुटि के साथ अपना प्रश्न अपडेट कर सकते हैं। शायद [प्रलेखन] (https://developer.android.com/tools/debugging/debugging-studio.html) देखें। – M0CH1R0N

संबंधित मुद्दे