三星Galaxy s4中的QR扫描问题

Question

我已经创建了一个可以扫描二维码的应用程序，它适用于所有Android设备，不包括三星Galaxy s4。
应用程序在使用Galaxy s4设备时不扫描任何QR码。
现在，作为这款Galaxy S4拥有Android 4.2.2版本，我还在其他具有与Nexus-4相同的Android版本（4.2.2）的设备中验证了我的应用，并且它可以正常工作。
是否有其他硬件用于扫描Galaxy s4中的QR码？
需要帮助来解决这个奇怪的问题！

以下是我在我的应用程序中使用的代码。

CameraManager.java

/** 
* This object wraps the Camera service object and expects to be the only one talking to it. The 
* implementation encapsulates the steps needed to take preview-sized images, which are used for 
* both preview and decoding. 
* 
* @author dswitkin@google.com (Daniel Switkin) 
*/ 
public final class CameraManager { 

    private static final String TAG = CameraManager.class.getSimpleName(); 

    private static final int MIN_FRAME_WIDTH = 240; 
    private static final int MIN_FRAME_HEIGHT = 240; 
    private static final int MAX_FRAME_WIDTH = 480; 
    private static final int MAX_FRAME_HEIGHT = 360; 

    private static CameraManager cameraManager; 

    static final int SDK_INT; // Later we can use Build.VERSION.SDK_INT 
    static { 
    int sdkInt; 
    try { 
     sdkInt = Integer.parseInt(Build.VERSION.SDK); 
    } catch (NumberFormatException nfe) { 
     // Just to be safe 
     sdkInt = 10000; 
    } 
    SDK_INT = sdkInt; 
    } 

    private final Context context; 
    private final CameraConfigurationManager configManager; 
    private Camera camera; 
    private Rect framingRect; 
    private Rect framingRectInPreview; 
    private boolean initialized; 
    private boolean previewing; 
    private boolean reverseImage; 
    private final boolean useOneShotPreviewCallback; 
    /** 
    * Preview frames are delivered here, which we pass on to the registered handler. Make sure to 
    * clear the handler so it will only receive one message. 
    */ 
    private final PreviewCallback previewCallback; 

    /** Autofocus callbacks arrive here, and are dispatched to the Handler which requested them. */ 
    private final AutoFocusCallback autoFocusCallback; 

    /** 
    * Initializes this static object with the Context of the calling Activity. 
    * 
    * @param context The Activity which wants to use the camera. 
    */ 
    public static void init(Context context) { 
    if (cameraManager == null) { 
     cameraManager = new CameraManager(context); 
    } 
    } 

    /** 
    * Gets the CameraManager singleton instance. 
    * 
    * @return A reference to the CameraManager singleton. 
    */ 
    public static CameraManager get() { 
    return cameraManager; 
    } 

    private CameraManager(Context context) { 

    this.context = context; 
    this.configManager = new CameraConfigurationManager(context); 

    // Camera.setOneShotPreviewCallback() has a race condition in Cupcake, so we use the older 
    // Camera.setPreviewCallback() on 1.5 and earlier. For Donut and later, we need to use 
    // the more efficient one shot callback, as the older one can swamp the system and cause it 
    // to run out of memory. We can't use SDK_INT because it was introduced in the Donut SDK. 
    useOneShotPreviewCallback = Integer.parseInt(Build.VERSION.SDK) > 3; // 3 = Cupcake 

    previewCallback = new PreviewCallback(configManager, useOneShotPreviewCallback); 
    autoFocusCallback = new AutoFocusCallback(); 
    } 

    /** 
    * Opens the camera driver and initializes the hardware parameters. 
    * 
    * @param holder The surface object which the camera will draw preview frames into. 
    * @throws IOException Indicates the camera driver failed to open. 
    */ 
    public void openDriver(SurfaceHolder holder) throws IOException { 
    if (camera == null) { 
     camera = Camera.open(); 
     if (camera == null) { 
     throw new IOException(); 
     } 
    } 
    camera.setPreviewDisplay(holder); 
    if (!initialized) { 
     initialized = true; 
     configManager.initFromCameraParameters(camera); 
    } 
    configManager.setDesiredCameraParameters(camera); 

    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context); 
    reverseImage = prefs.getBoolean(PreferencesActivity.KEY_REVERSE_IMAGE, false); 
    if (prefs.getBoolean(PreferencesActivity.KEY_FRONT_LIGHT, false)) { 
     FlashlightManager.enableFlashlight(); 
    } 
    } 

    /** 
    * Closes the camera driver if still in use. 
    */ 
    public void closeDriver() { 
    if (camera != null) { 
     FlashlightManager.disableFlashlight(); 
     camera.release(); 
     camera = null; 

     // Make sure to clear these each time we close the camera, so that any scanning rect 
     // requested by intent is forgotten. 
     framingRect = null; 
     framingRectInPreview = null; 
    } 
    } 

    /** 
    * Asks the camera hardware to begin drawing preview frames to the screen. 
    */ 
    public void startPreview() { 
    if (camera != null && !previewing) { 
     camera.startPreview(); 
     previewing = true; 
    } 
    } 

    /** 
    * Tells the camera to stop drawing preview frames. 
    */ 
    public void stopPreview() { 
    if (camera != null && previewing) { 
     if (!useOneShotPreviewCallback) { 
     camera.setPreviewCallback(null); 
     } 
     camera.stopPreview(); 
     previewCallback.setHandler(null, 0); 
     autoFocusCallback.setHandler(null, 0); 
     previewing = false; 
    } 
    } 

    /** 
    * A single preview frame will be returned to the handler supplied. The data will arrive as byte[] 
    * in the message.obj field, with width and height encoded as message.arg1 and message.arg2, 
    * respectively. 
    * 
    * @param handler The handler to send the message to. 
    * @param message The what field of the message to be sent. 
    */ 
    public void requestPreviewFrame(Handler handler, int message) { 
    if (camera != null && previewing) { 
     previewCallback.setHandler(handler, message); 
     if (useOneShotPreviewCallback) { 
     camera.setOneShotPreviewCallback(previewCallback); 
     } else { 
     camera.setPreviewCallback(previewCallback); 
     } 
    } 
    } 

    /** 
    * Asks the camera hardware to perform an autofocus. 
    * 
    * @param handler The Handler to notify when the autofocus completes. 
    * @param message The message to deliver. 
    */ 
    public void requestAutoFocus(Handler handler, int message) { 
    if (camera != null && previewing) { 
     autoFocusCallback.setHandler(handler, message); 
     //Log.d(TAG, "Requesting auto-focus callback"); 
     camera.autoFocus(autoFocusCallback); 
    } 
    } 

    /** 
    * Calculates the framing rect which the UI should draw to show the user where to place the 
    * barcode. This target helps with alignment as well as forces the user to hold the device 
    * far enough away to ensure the image will be in focus. 
    * 
    * @return The rectangle to draw on screen in window coordinates. 
    */ 
    public Rect getFramingRect() { 
    if (framingRect == null) { 
     if (camera == null) { 
     return null; 
     } 
     Point screenResolution = configManager.getScreenResolution(); 
     int width = screenResolution.x * 3/4; 
     if (width < MIN_FRAME_WIDTH) { 
     width = MIN_FRAME_WIDTH; 
     } else if (width > MAX_FRAME_WIDTH) { 
     width = MAX_FRAME_WIDTH; 
     } 
     int height = screenResolution.y * 3/4; 
     if (height < MIN_FRAME_HEIGHT) { 
     height = MIN_FRAME_HEIGHT; 
     } else if (height > MAX_FRAME_HEIGHT) { 
     height = MAX_FRAME_HEIGHT; 
     } 
     int leftOffset = (screenResolution.x - width)/2; 
     int topOffset = (screenResolution.y - height)/2; 
     framingRect = new Rect(leftOffset, topOffset, leftOffset + width, topOffset + height); 
     Log.d(TAG, "Calculated framing rect: " + framingRect); 
    } 
    return framingRect; 
    } 

    /** 
    * Like {@link #getFramingRect} but coordinates are in terms of the preview frame, 
    * not UI/screen. 
    */ 
    public Rect getFramingRectInPreview() { 
    if (framingRectInPreview == null) { 
     Rect rect = new Rect(getFramingRect()); 
     Point cameraResolution = configManager.getCameraResolution(); 
     Point screenResolution = configManager.getScreenResolution(); 

     /* updated to allow for portrait instead of landscape 
     rect.left = rect.left * cameraResolution.y/screenResolution.x; 
     rect.right = rect.right * cameraResolution.y/screenResolution.x; 
     rect.top = rect.top * cameraResolution.x/screenResolution.y; 
     rect.bottom = rect.bottom * cameraResolution.x/screenResolution.y; */ 

     rect.left = rect.left * cameraResolution.x/screenResolution.x; 
     rect.right = rect.right * cameraResolution.x/screenResolution.x; 
     rect.top = rect.top * cameraResolution.y/screenResolution.y; 
     rect.bottom = rect.bottom * cameraResolution.y/screenResolution.y; 
     framingRectInPreview = rect; 
    } 
    return framingRectInPreview; 
    } 

    /** 
    * Allows third party apps to specify the scanning rectangle dimensions, rather than determine 
    * them automatically based on screen resolution. 
    * 
    * @param width The width in pixels to scan. 
    * @param height The height in pixels to scan. 
    */ 
    public void setManualFramingRect(int width, int height) { 
    Point screenResolution = configManager.getScreenResolution(); 
    if (width > screenResolution.x) { 
     width = screenResolution.x; 
    } 
    if (height > screenResolution.y) { 
     height = screenResolution.y; 
    } 
    int leftOffset = (screenResolution.x - width)/2; 
    int topOffset = (screenResolution.y - height)/2; 
    framingRect = new Rect(leftOffset, topOffset, leftOffset + width, topOffset + height); 
    Log.d(TAG, "Calculated manual framing rect: " + framingRect); 
    framingRectInPreview = null; 
    } 

    /** 
    * A factory method to build the appropriate LuminanceSource object based on the format 
    * of the preview buffers, as described by Camera.Parameters. 
    * 
    * @param data A preview frame. 
    * @param width The width of the image. 
    * @param height The height of the image. 
    * @return A PlanarYUVLuminanceSource instance. 
    */ 
    public PlanarYUVLuminanceSource buildLuminanceSource(byte[] data, int width, int height) { 
    Rect rect = getFramingRectInPreview(); 
    int previewFormat = configManager.getPreviewFormat(); 
    String previewFormatString = configManager.getPreviewFormatString(); 

    switch (previewFormat) { 
     // This is the standard Android format which all devices are REQUIRED to support. 
     // In theory, it's the only one we should ever care about. 
     case PixelFormat.YCbCr_420_SP: 
     // This format has never been seen in the wild, but is compatible as we only care 
     // about the Y channel, so allow it. 
     case PixelFormat.YCbCr_422_SP: 
     return new PlanarYUVLuminanceSource(data, width, height, rect.left, rect.top, 
      rect.width(), rect.height(), reverseImage); 
     default: 
     // The Samsung Moment incorrectly uses this variant instead of the 'sp' version. 
     // Fortunately, it too has all the Y data up front, so we can read it. 
     if ("yuv420p".equals(previewFormatString)) { 
      return new PlanarYUVLuminanceSource(data, width, height, rect.left, rect.top, 
       rect.width(), rect.height(), reverseImage); 
     } 
    } 
    throw new IllegalArgumentException("Unsupported picture format: " + 
     previewFormat + '/' + previewFormatString); 
    } 

} 

PreviewCallback.java

final class PreviewCallback implements Camera.PreviewCallback { 

    private static final String TAG = PreviewCallback.class.getSimpleName(); 

    private final CameraConfigurationManager configManager; 
    private final boolean useOneShotPreviewCallback; 
    private Handler previewHandler; 
    private int previewMessage; 

    PreviewCallback(CameraConfigurationManager configManager, boolean useOneShotPreviewCallback) { 
    this.configManager = configManager; 
    this.useOneShotPreviewCallback = useOneShotPreviewCallback; 
    } 

    void setHandler(Handler previewHandler, int previewMessage) { 
    this.previewHandler = previewHandler; 
    this.previewMessage = previewMessage; 
    } 

    public void onPreviewFrame(byte[] data, Camera camera) { 
    Point cameraResolution = configManager.getCameraResolution(); 
    if (!useOneShotPreviewCallback) { 
     camera.setPreviewCallback(null); 
    } 
    if (previewHandler != null) { 
     Message message = previewHandler.obtainMessage(previewMessage, cameraResolution.x, 
      cameraResolution.y, data); 
     message.sendToTarget(); 
     previewHandler = null; 
    } else { 
     Log.d(TAG, "Got preview callback, but no handler for it"); 
    } 
    } 

} 

Answer 1

你应该设置相机预览格式启动预览模式之前。 是的，Android文档说默认格式应该是PixelFormat.YCbCr_420_SP = 17，但我看到一些设备不遵循这个规则。还有一些使用yuyv打包422格式，它没有亮度块来复制，因为你的代码，但需要重新洗牌的字节。设置预览宽度和高度也是明智之举。很可能您不需要超过VGA分辨率来扫描QR码。

更新：在我的设备上，默认预览帧为1920x1080像素。请注意，这是16：9，而不是4：3的宽高比。我在你的代码中看到了对硬编码4：3的一些引用，但是如果这个假设被用来解释QR码，这可能是失败的原因。