2012-10-05 25 views
5

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

धन्यवाद।

मेरा कोड नीचे है।

public class CameraActivity extends Activity implements SurfaceHolder.Callback, Camera.ShutterCallback, Camera.PictureCallback { 

Camera m_camera; 
SurfaceView m_surfaceView; 
int m_numOfCamera; 
int m_defaultCameraId; 
int m_currentCamera; 
int m_surfaceWidth; 
int m_surfaceHeight; 

@Override 
public void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    setContentView(R.layout.activity_camera); 
    getActionBar().setDisplayHomeAsUpEnabled(true); 


    m_surfaceView = (SurfaceView)findViewById(R.id.cameraPreview); 
    m_surfaceView.getHolder().addCallback(this); 

    m_camera = Camera.open(); 

    m_numOfCamera = Camera.getNumberOfCameras(); 

    CameraInfo cameraInfo = new CameraInfo(); 
    for (int i = 0; i < m_numOfCamera; ++i) { 
     Camera.getCameraInfo(i, cameraInfo); 
     if (cameraInfo.facing == CameraInfo.CAMERA_FACING_BACK) { 
      m_defaultCameraId = i; 
      m_currentCamera = m_defaultCameraId; 
     }  
    } 

    if (m_numOfCamera < 1) { 
     MenuItem switchCam = (MenuItem)findViewById(R.id.menu_switch_camera); 
     switchCam.setVisible(false); 
    } 
} 

@Override 
public void onPause() { 
    super.onPause(); 
    m_camera.stopPreview(); 
} 

@Override 
public void onDestroy() { 
    super.onDestroy(); 
    m_camera.release(); 
} 

@Override 
public boolean onCreateOptionsMenu(Menu menu) { 
    getMenuInflater().inflate(R.menu.activity_camera, menu); 
    return true; 
} 

@Override 
public boolean onOptionsItemSelected(final MenuItem item) 
{ 
    if (item.getItemId() == android.R.id.home) 
    { 
     Intent intent = new Intent(this, MainActivity.class); 
     intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); 
     startActivity(intent); 

     return true; 
    } 
    else if (item.getItemId() == R.id.menu_switch_camera) 
    { 
     if (m_camera != null) { 
      m_camera.stopPreview(); 
      m_camera.release(); 
      m_camera = null; 
     } 

     m_camera = Camera.open((m_currentCamera + 1) % m_numOfCamera); 
     m_currentCamera = (m_currentCamera + 1) % m_numOfCamera; 

     Camera.Parameters params = m_camera.getParameters(); 
     List<Camera.Size> sizes = params.getSupportedPreviewSizes(); 
     Camera.Size size = getOptimalPreviewSize(sizes, m_surfaceWidth, m_surfaceHeight); 

     params.setPreviewSize(size.width, size.height); 

     m_camera.setParameters(params); 
     setCameraDisplayOrientation(this, m_currentCamera, m_camera); 
     m_camera.startPreview(); 
     try { 
      m_camera.setPreviewDisplay(m_surfaceView.getHolder()); 
     } catch (Exception e) { 
      e.printStackTrace(); 
     } 
     return true; 
    } 
    return true; 
} 

public void onPictureTaken(byte[] arg0, Camera arg1) { 
    // TODO Auto-generated method stub 

} 

public void onShutter() { 
    // TODO Auto-generated method stub 

} 

public void surfaceChanged(SurfaceHolder arg0, int format, int w, int h) { 
    m_surfaceWidth = w; 
    m_surfaceHeight = h; 
    Camera.Parameters params = m_camera.getParameters(); 
    List<Camera.Size> sizes = params.getSupportedPreviewSizes(); 
    Camera.Size selected = getOptimalPreviewSize(sizes, w, h); 

    params.setPreviewSize(selected.width, selected.height); 


    m_camera.setParameters(params); 
    setCameraDisplayOrientation(this, m_currentCamera, m_camera); 
    m_camera.startPreview();  
} 

private static void setCameraDisplayOrientation(Activity activity, 
     int cameraId, android.hardware.Camera camera) { 
    android.hardware.Camera.CameraInfo info = 
      new android.hardware.Camera.CameraInfo(); 
    android.hardware.Camera.getCameraInfo(cameraId, info); 
    int rotation = activity.getWindowManager().getDefaultDisplay() 
      .getRotation(); 
    int degrees = 0; 
    switch (rotation) { 
     case Surface.ROTATION_0: degrees = 0; break; 
     case Surface.ROTATION_90: degrees = 90; break; 
     case Surface.ROTATION_180: degrees = 180; break; 
     case Surface.ROTATION_270: degrees = 270; break; 
    } 

    int result; 
    if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) { 
     result = (info.orientation + degrees) % 360; 
     result = (360 - result) % 360; // compensate the mirror 
    } else { // back-facing 
     result = (info.orientation - degrees + 360) % 360; 
    } 
    camera.setDisplayOrientation(result); 
} 


public void surfaceCreated(SurfaceHolder arg0) { 
    try { 
     m_camera.setPreviewDisplay(m_surfaceView.getHolder()); 
    } catch (Exception e) { 
     e.printStackTrace(); 
    } 
} 

public void surfaceDestroyed(SurfaceHolder arg0) { 
    // TODO Auto-generated method stub 

} 

private Size getOptimalPreviewSize(List<Size> sizes, int w, int h) { 


    final double ASPECT_TOLERANCE = 0.1; 
    double targetRatio = (double) w/h; 
    if (sizes == null) 
     return null; 

    Size optimalSize = null; 
    double minDiff = Double.MAX_VALUE; 

    int targetHeight = h; 

    // Try to find an size match aspect ratio and size 
    for (Size size : sizes) { 
     double ratio = (double) size.width/size.height; 
     if (Math.abs(ratio - targetRatio) > ASPECT_TOLERANCE) 
      continue; 
     if (Math.abs(size.height - targetHeight) < minDiff) { 
      optimalSize = size; 
      minDiff = Math.abs(size.height - targetHeight); 
     } 
    } 

    // Cannot find the one match the aspect ratio, ignore the requirement 
    if (optimalSize == null) { 
     minDiff = Double.MAX_VALUE; 
     for (Size size : sizes) { 
      if (Math.abs(size.height - targetHeight) < minDiff) { 
       optimalSize = size; 
       minDiff = Math.abs(size.height - targetHeight); 
      } 
     } 
    } 

    return optimalSize; 
} 

} 

उत्तर

15

कैमरा पूर्वावलोकन हमेशा SurfaceView को दिखाता है। यदि m_surfaceView का पहलू अनुपात कैमरे के पहलू अनुपात से मेल नहीं खाता है, तो पूर्वावलोकन बढ़ाया जाएगा।

आपको पहलू अनुपात से मेल खाने वाले m_surfaceView बनाना होगा। इसका मतलब है, आपको लेआउट एक्सएमएल फ़ाइल से नहीं, कोड से इसे बनाना होगा।

एक नमूना प्रोजेक्ट एपिडेमोस है जो आपको एंड्रॉइड नमूना परियोजनाओं में मिलेगा। प्रोजेक्ट में CameraPreview नाम की एक चीज़ है। SurfaceView में कैमरा पूर्वावलोकन सेट अप करने के लिए इसका एक अच्छा प्रदर्शन है। इसमें एक वर्ग है जो extends ViewGroup है, और कोड से अपने बच्चे के रूप में SurfaceView जोड़ता है। onMeasure() विधि SurfaceView की ऊंचाई और चौड़ाई निर्धारित करने के लिए ओवरराइड कर दी गई है, इसलिए पहलू अनुपात संरक्षित है। परियोजना पर एक नज़र डालें, और मुझे उम्मीद है कि यह स्पष्ट होगा।

[क्षमा करें मैं यहां लिंक पोस्ट नहीं कर सका - this लिंक होना चाहिए, लेकिन मुझे यह टूटा हुआ पाया। लेकिन अगर आपने एंड्रॉइड एसडीके के साथ नमूना परियोजनाएं स्थापित की हैं, तो आप नमूने में प्रोजेक्ट पा सकते हैं। एक नया एंड्रॉइड नमूना प्रोजेक्ट खोलें, एपीआईडीमोस का चयन करें, फिर CameraPreview नामक कक्षा की तलाश करें। जहां तक ​​मुझे याद है, पैकेज com.example.android.apis.graphics में होना चाहिए।]

+0

धन्यवाद surfaceChanged परिवर्तन Parametrs.setPreviewSize (एक्स, वाई) आपके द्वारा प्राप्त की एक समारोह है बहुत! मैं कोशिश करूँगा। –

+2

यह कैसे संभव है कि किसी भी डिवाइस के नियमित कैमरे में बिना किसी खिंचाव के पूर्ण स्क्रीन पूर्वावलोकन हो? – idish

+0

मुझे इसे एसडीके/नमूना/एड्रॉइड -18 के अंदर मिला। धन्यवाद –

0

मैंने लेआउट विधि बदल दी है और कैमरा पूर्वावलोकन नहीं बढ़ाया गया है। बाकी चीज एपीडीडो की तरह ही है जो यहां एसडीके/नमूना/एड्रॉइड -18 मिलती है। विचार यह है कि हमारे पास पूर्वावलोकन का केवल कुछ समर्थित आकार है लेकिन हमारा दृश्य आकार हमेशा पूर्वावलोकन आकार के साथ मेल नहीं खाता है। तो मैंने अपने पूर्वावलोकन दृश्य आकार के बाद बड़े पूर्वावलोकन आकार लिया। इससे मेरा काम बनता है। किसी की मदद कर सकते हैं ..

@Override 
    protected void onLayout(boolean changed, int l, int t, int r, int b) { 
     if (changed && getChildCount() > 0) { 
      final View child = getChildAt(0); 

      final int width = r - l; 
      final int height = b - t; 

      int previewWidth = width; 
      int previewHeight = height; 
      if (mPreviewSize != null) { 
       previewWidth = mPreviewSize.width; 
       previewHeight = mPreviewSize.height; 
      } 

      // Center the child SurfaceView within the parent. 
      if (width * previewHeight < height * previewWidth) { 

       final int scaledChildWidth = previewWidth * height 
         /previewHeight; 

       left = (width - scaledChildWidth)/2; 
       top = 0; 
       right = (width + scaledChildWidth)/2; 
       bottom = height; 

       child.layout(left, top, right, bottom); 
      } else { 
       final int scaledChildHeight = previewHeight * width 
         /previewWidth; 

       left = 0; 
       top = (height - scaledChildHeight)/2; 
       right = width; 
       bottom = (height + scaledChildHeight)/2; 

       child.layout(left, top, right, bottom); 
      } 
     } 
    } 
+0

क्या छोड़ा जा सकता है, दाएं, नीचे और ऊपर, जहां उन्हें घोषित किया जाता है? वही एल, आर, टी, बी? – desgraci

+0

इसकी एक ओवरराइड विधि है, आपको इसके लिए मान पास करने की आवश्यकता नहीं है। यह आपके लेआउट के अनुसार एल, आर, टी, बी मान लेगा –

0

मुझे कैमरे के पूर्वावलोकन को बहुत खींचने में समस्या है। यह लंबवत और लैंडस्केप मोड पर खींच रहा है।

तो प्रकट पर मैं screenOrentation = "चित्र", जोड़ा है, लेकिन यह मदद नहीं की, अभी भी पूर्वावलोकन पर किसी भी स्थिति पुनः पैमाना है (ऊर्ध्वाधर - पूर्वावलोकन करने के लिए व्यापक है या परिदृश्य बहुत लंबा है) आप पर यह देख सकते स्क्रीन। मैं सैमसंग इक्का में जोड़ने के लिए तृतीय सब कुछ ठीक है लेकिन एलजी नेक्सस 4 है पर खींच

package pl.probs.camera.component; 

import java.io.IOException; 
import java.util.ArrayList; 
import java.util.Collections; 
import java.util.Comparator; 
import java.util.List; 
import android.annotation.SuppressLint; 
import android.app.Activity; 
import android.content.Context; 
import android.graphics.Point; 
import android.hardware.Camera; 
import android.hardware.Camera.AutoFocusCallback; 
import android.hardware.Camera.CameraInfo; 
import android.hardware.Camera.Parameters; 
import android.hardware.Camera.Size; 
import android.util.Log; 
import android.view.Display; 
import android.view.MotionEvent; 
import android.view.Surface; 
import android.view.SurfaceHolder; 
import android.view.SurfaceView; 
import pl.probs.lib.debug.L; 

public class CameraPreview extends SurfaceView implements SurfaceHolder.Callback { 
    private static final String TAG = "CameraPreview"; 
    private static boolean showLogs = true; 
    private SurfaceHolder mHolder; 
    private Camera mCamera; 
    private Context context; 
    private Parameters resolution; 
    private List<Size> lSuportedPreviewSize; 
    private static int cOrientation = 0; // aktualny kat orientacji 
    private static boolean cOrientationChanged = false; // Stan orientacji 
                 // zostal zmieniony 
                 // wzgledem poprzedniego 
    private Display display; // Rozmiar ekranu 
    private Point displaySize; // Zmienna przechowuje Rozmiar Ekranu 
    private Point optimalPreviewSize; 
public CameraPreview(Context context, Camera camera, int resolution) { 
    super(context); 
    this.optimalPreviewSize = new Point(); 
    this.context = context; 
    this.mCamera = camera; 
    setDisplaySize(this.display); 
    setFocusable(true); 
    setFocusableInTouchMode(true); 
    mHolder = getHolder(); 
    mHolder.addCallback(this); 
    mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS); 
    this.resolution = getMinResolution(resolution); 
    this.optimalPreviewSize = getOptimalPreviewResolution(this.display); 
    Size s = mCamera.getParameters().getPreviewSize(); // Sprawdzenie jaki 
                 // prewiev ustawiony 
} 

public Point getOptimalPreviewSize() { 
    return optimalPreviewSize; 
} 

public void surfaceCreated(SurfaceHolder holder) { 
    try { 
     if (mCamera != null) { 
      mCamera.stopPreview(); 
      mCamera.setPreviewDisplay(holder); 
      Size s = mCamera.getParameters().getPreviewSize(); 
      mCamera.startPreview(); 
     } 
    } catch (IOException e) { 
     L.d("Błąd ustawiania podglÄ…du: " + e.getMessage()); 
    } 
} 

protected void onPause() { 
    // Because the Camera object is a shared resource, it's very 
    // important to release it when the activity is paused. 
    if (mCamera != null) { 
     mCamera.release(); 
     mCamera = null; 
    } 
} 

public void surfaceDestroyed(SurfaceHolder holder) { 
    if (mCamera != null) { 
     mCamera.stopPreview(); 
    } 
} 

public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) { 
    Camera.Parameters setPrevOrientation = mCamera.getParameters(); 
    if (mHolder.getSurface() == null) 
     return; 

    try { 
     mCamera.stopPreview(); 
     Size sizeBefore = mCamera.getParameters().getPreviewSize(); 
     setPrevOrientation.setRotation(setCameraDisplayOrientation((Activity) context, getCameraId(), mCamera)); 
     // Orientacja Portrait np 640x480 Landscape 480x640 
     this.resolution.setPreviewSize(this.optimalPreviewSize.x, this.optimalPreviewSize.y); 
     mCamera.setParameters(this.resolution); 
     Size sizeAfter = mCamera.getParameters().getPreviewSize(); 
    } catch (RuntimeException e) { 
     L.d("Podgląd nie istnieje"); 
    } 

    try { 
     mCamera.stopPreview(); 
     mCamera.setPreviewDisplay(mHolder); 
     mCamera.startPreview(); 

    } catch (Exception e) { 
     L.d("błąd podgladu: " + e.getMessage()); 
    } 
} 

@SuppressLint("ClickableViewAccessibility") 
public boolean onTouchEvent(MotionEvent event) { 
    if (event.getAction() == MotionEvent.ACTION_DOWN) { 
     mCamera.autoFocus(new AutoFocusCallback() { 

      @Override 
      public void onAutoFocus(boolean success, Camera camera) { 
       // do something 
      } 
     }); 

    } 

    return true; 
} 

private static int setCameraDisplayOrientation(Activity activity, int cameraId, android.hardware.Camera camera) { 
    android.hardware.Camera.CameraInfo info = new android.hardware.Camera.CameraInfo(); 

    android.hardware.Camera.getCameraInfo(cameraId, info); 
    int rotation = activity.getWindowManager().getDefaultDisplay().getRotation(); 
    int degrees = 0; 
    switch (rotation) { 
    case Surface.ROTATION_0: 
     degrees = 0; 
     break; 
    case Surface.ROTATION_90: 
     degrees = 90; 
     break; 
    case Surface.ROTATION_180: 
     degrees = 180; 
     break; 
    case Surface.ROTATION_270: 
     degrees = 270; 
     break; 
    } 

    cOrientation = degrees; 

    int result; 
    if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) { 
     result = (info.orientation + degrees) % 360; 
     result = (360 - result) % 360; // compensate the mirror 
    } else { // back-facing 
     result = (info.orientation - degrees + 360) % 360; 
    } 

    camera.setDisplayOrientation(result); 
    return result; 
} 

private int getCameraId() { 
    int cameraId = -1; 
    int numberOfCameras = Camera.getNumberOfCameras(); 
    for (int i = 0; i < numberOfCameras; i++) { 
     CameraInfo info = new CameraInfo(); 
     Camera.getCameraInfo(i, info); 
     if (info.facing == CameraInfo.CAMERA_FACING_BACK) { 
      cameraId = i; 
      break; 
     } 
    } 
    return cameraId; 
} 

private Parameters getMinResolution(int desireResolutionInMpx) { 
    int height[], width[], size; 
    float megapixels; 
    Camera.Parameters p = mCamera.getParameters(); 
    size = p.getSupportedPictureSizes().size(); 
    height = new int[size]; 
    width = new int[size]; 
    for (int i = 0; i < size; i++) { 
     height[i] = p.getSupportedPictureSizes().get(i).height; 
     width[i] = p.getSupportedPictureSizes().get(i).width; 
     megapixels = (float) (((float) height[i] * (float) width[i])/1024000); 
     if (megapixels <= desireResolutionInMpx) { 
      p.setPictureSize(width[i], height[i]); 
      break; 
     } 
    } 
    return p; 
} 

private Point getOptimalPreviewResolution(Display displaySize) { 
    lSuportedPreviewSize = mCamera.getParameters().getSupportedPreviewSizes(); 
    Point optimalPreviewSize = new Point(); 
    int displayWidth = displaySize.getWidth(); // szerokosc ekranu 
    int displayHeight = displaySize.getHeight(); // wysokosc ekranu 
    int cameraHeight; // wspierana wysokosc kamery 
    int cameraWidth; // wspierana szerokosc kamery 

    // Lista przechowywujace SupportedPreviewSize kamery, wszyskie 
    // rozdzielczosci mniejsze od szerokosc i wysokosci ekranu 
    List<Point> lOptimalPoint = new ArrayList<Point>(); 

    // Pomocniczo do listowania zawartosci listy 
    // TODO manta displayHeight cameraHeight brak oraz width brak zgodnosci 
    // (
    System.out.println(lOptimalPoint.toString()); 
    for (int i = 0; i < lSuportedPreviewSize.size(); i++) { 
     Log.i(TAG, "w " + lSuportedPreviewSize.get(i).width + " h " + lSuportedPreviewSize.get(i).height + " \n"); 
    } 

    // Wyszukanie wszystkich wysokosci kamery mniejszej od wysokosci ekranu 
    for (int i = 0; i < lSuportedPreviewSize.size(); i++) { 
     // TODO Uwazaj kamera zapisuje swoj rozmiar dla pozycji landscape 
     // gdzie height = 480 a width = 800 
     cameraHeight = lSuportedPreviewSize.get(i).width; 
     cameraWidth = lSuportedPreviewSize.get(i).height; 
     // Porownaj wysokosc ekranu urzadzenia z wysokosci supportedPreview 
     // dodaj do listy 
     if (displayHeight > cameraHeight) { 
      lOptimalPoint.add(new Point(cameraHeight, cameraWidth)); 
     } 
    } 

    // Sortowanie rosnaco 
    Collections.sort(lOptimalPoint, new ComapreSupportedPreviewByWidth()); 
    // Ostatni element listy optymalny 
    optimalPreviewSize = lOptimalPoint.get(lOptimalPoint.size()-1); 

    // Zwracana rozdzielczosc landscape aparatu np (800x600) 
    return optimalPreviewSize; 
} 

private void setDisplaySize(Display display) { 
    Activity activity = (Activity) this.context; // Pobierz aktywnosc aby 
                // znać rozmiar ekranu 

    this.display = activity.getWindowManager().getDefaultDisplay(); 
} 

class ComapreSupportedPreviewByWidth implements Comparator<Point> { 

    @Override 
    public int compare(Point lhs, Point rhs) { 
     return lhs.x - rhs.x; 
    } 
} 

}

Link to screens and project doing at eclipse

0

मैं पहले से ही हल समस्या चाहते हैं। अजीब कैमरा पूर्वावलोकन के साथ समस्या का कारण क्या हो सकता है।

  • स्थिति पट्टी रिक्त स्थान लेता है - आप छिपा कर सकते हैं यह Hiding the Status Bar

  • कुछ रिक्त स्थान भी शीर्षक पट्टी ले - आप प्रकट

    पर

एंड्रॉयड बंद कर सकते हैं: विषय = "@ एंड्रॉइड: शैली/थीम.NoTitleBar ">

  • परिदृश्य में बदला गया गतिविधि उन्मुखीकरण "क्योंकि कैमरा पूर्वावलोकन समर्थन उन्मुखीकरण कि" - आप API demo ग्राफिक्स> CameraPreview

  • एल्गोरिथ्म है कि (Display.getWidth के आकार तुलना में इस जाँच कर सकते हैं) Camera.getParameters आकार()। प्राप्त करें समर्थित पूर्वावलोकन पूर्वावलोकन(); वे कर रहे हैं अगर एक ही जब सूची खोज


public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) { 
    Camera.Parameters setPrevOrientation = mCamera.getParameters(); 
    if (mHolder.getSurface() == null) 
     return; 

    try { 
     mCamera.stopPreview(); 
     Size sizeBefore = mCamera.getParameters().getPreviewSize(); 
     setPrevOrientation.setRotation(setCameraDisplayOrientation(
       (Activity) context, getCameraId(), mCamera)); 
     // Orientacja Portrait np 640x480 Landscape 480x640 
     this.resolution.setPreviewSize(this.optimalPreviewSize.x, 
       this.optimalPreviewSize.y); 
     mCamera.setParameters(this.resolution); 
     Size sizeAfter = mCamera.getParameters().getPreviewSize(); 
    } catch (RuntimeException e) { 

     L.d("Podgląd nie istnieje"); 
    } 

    try { 
     mCamera.stopPreview(); 
     mCamera.setPreviewDisplay(mHolder); 
     mCamera.startPreview(); 

    } catch (Exception e) { 
     L.d("błąd podgladu: " + e.getMessage()); 
    } 
} 

private Point getOptimalPreviewResolution(Display displaySize) { 

     lSuportedPreviewSize = mCamera.getParameters() 
       .getSupportedPreviewSizes(); 
     Point optimalPreviewSize = new Point(); 
     int displayWidth = displaySize.getWidth(); 
     int displayHeight = displaySize.getHeight(); 
     int cameraHeight; 
     int cameraWidth; 

     List<Point> lOptimalPoint = new ArrayList<Point>(); 

     for (int i = 0; i < lSuportedPreviewSize.size(); i++) { 
      cameraHeight = lSuportedPreviewSize.get(i).width; 
      cameraWidth = lSuportedPreviewSize.get(i).height; 
      if (displayHeight >= cameraHeight) { 
       lOptimalPoint.add(new Point(cameraHeight, cameraWidth)); 
      } 
     } 

     // Sort ascending 
     Collections.sort(lOptimalPoint, 
       new ComapreSupportedPreviewByWidth()); 
     // Last element is optimal 
     optimalPreviewSize = lOptimalPoint.get(lOptimalPoint.size() - 1); 

     // Return resolution - camera at landscape mode (800x600) 
     return optimalPreviewSize; 
    } 

class ComapreSupportedPreviewByWidth implements Comparator<Point> { 

    @Override 
    public int compare(Point lhs, Point rhs) { 
     return lhs.x - rhs.x; 
    } 
संबंधित मुद्दे