किसी छवि को कैप्चर करने के बाद StartPreview() को कॉल करने का सबसे अच्छा तरीका क्या है?

Question

कैमरा.takePicture() पर कॉल करने के बाद, मेरा पूर्वावलोकन दस्तावेज़ों में वर्णित अनुसार अपडेट करना बंद कर देगा। यह पता लगाने का सबसे अच्छा तरीका क्या है कि छवि कैप्चर प्रक्रिया समाप्त हो गई है और इसे फिर से अपडेट करना शुरू करने के लिए स्टार्ट पूर्वावलोकन() को कॉल करें?

कॉल को पास करने के लिए पास किए गए किसी भी कॉलबैक में नहीं रखा जा सकता है, दस्तावेज़ों के मुताबिक, जैसा कि मैंने इसे आमंत्रित करने से पहले सभी को वापस कर दिया होगा।

मेरा वर्तमान सबसे अच्छा अनुमान हैंडलर बनाना और जेपीईजी कॉलबैक (या जो भी लौटने वाला सबसे आखिरी परिभाषित कॉलबैक है) से देरी हो सकती है।

Answer 1

आपको mCamera.take चित्र को AsyncTask (या थ्रेड) के भीतर से शुरू करना चाहिए, हालांकि AsyncTaks का आसान विकल्प है।

एक बहुत आसान कार्यान्वयन (जो निश्चित रूप से संशोधित किया जा सकता है) करने के लिए:

विधि चित्र लेने के लिए कहा जाता है

/** 
* Execute the AsyncTask that will handle the preview of the captured photo. 
*/ 
public void takePicture() { 
    TakePictureTask takePictureTask = new TakePictureTask(); 
    takePictureTask.execute(); 
} 

AsyncTask उपवर्ग

/** 
* A pretty basic example of an AsyncTask that takes the photo and 
* then sleeps for a defined period of time before finishing. Upon 
* finishing, it will restart the preview - Camera.startPreview(). 
*/ 

private class TakePictureTask extends AsyncTask<Void, Void, Void> { 

    @Override 
    protected void onPostExecute(Void result) { 
     // This returns the preview back to the live camera feed 
     mCamera.startPreview(); 
    } 

    @Override 
    protected Void doInBackground(Void... params) { 
     mCamera.takePicture(null, null, mPictureCallback); 

     // Sleep for however long, you could store this in a variable and 
     // have it updated by a menu item which the user selects. 
     try { 
      Thread.sleep(3000); // 3 second preview 
     } catch (InterruptedException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } 

     return null; 
    } 

} 

पिक्चरकॉलबैक फ़ील्ड

private PictureCallback mPictureCallback = new PictureCallback() { 

    @Override 
    public void onPictureTaken(byte[] data, Camera camera) { 
     File file = null; 

     // Check whether the media is mounted with read/write permission. 
     if (Environment.MEDIA_MOUNTED.equals(
       Environment.getExternalStorageState())) { 
      file = getOutputMediaFile(); 
     } 

     if (file == null) { 
      Log.d(TAG, "Error creating media file, check storage persmissions!"); 
      return; 
     } 

     try { 
      FileOutputStream fileOutputStream = new FileOutputStream(file); 
      fileOutputStream.write(data); 
      fileOutputStream.close(); 
     } catch (FileNotFoundException e) { 
      Log.d(TAG, "File not found: " + e.getMessage()); 
     } catch (IOException e) { 
      Log.d(TAG, "Error accessing file: " + e.getMessage()); 
     } 
    } 
}; 

Answer 2

के बाद से PictureCallback वैसे भी (यह यूआई ताला नहीं होगा) एक अलग थ्रेड में शुरू किया है, तो आप एक AsyncTask उपयोग करने के लिए कब्जा कॉल करने के लिए की जरूरत नहीं है।

वहाँ क्या आप क्या करना चाहते करने के लिए दो तरीके हैं, सबसे आसान निम्नलिखित है:

mCamera.startPreview(); //preview has to be started before you can take a picture 
mCamera.takePicture(null, null, mPictureCallback); //take a picture 

private PictureCallback mPictureCallback = new PictureCallback() { 
    @Override 
    public void onPictureTaken(byte[] data, Camera camera) { 
     camera.startPreview(); //once your camera has successfully finished 
           //its capture it's safe to restart the preview 
     ... //anything else you want to do to process that image 
    } 
} 

दूसरा एक गुमनाम समारोह, जैसे का उपयोग कर होगा:

mCamera.takePicture(null, null, new PictureCallback(){ 
    ... 
}); 

दोनों अपनी जरूरतों के आधार पर उनके उपयोग हैं।