Java Android ViewPager，片段中的cameraview未显示

我正在尝试创建一个包含3个片段的应用程序，我正在使用viewpager浏览它们
第一个是列表，第二个应该是相机，第三个也是列表。
刷卡有效，但当我到达第二个片段时，cameraPreview是黑色的。

我没有任何撞车或其他事情的痕迹。
我已经创建了这个应用程序的一部分，但没有刷卡，它确实工作了。在新应用中重新设置时，我没有更改片段，我只是将导入从android.app.fragment更改为android.support.v4.app.fragment

我使用此示例创建应用程序：

我的也没什么不同，我想感谢哈克索的伟大解释，它真的帮助了我。我还没法投票，所以我要这样感谢你：）

MainActivity.class：

import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentActivity;
import android.os.Bundle;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentPagerAdapter;
import android.support.v4.view.ViewPager;
import android.view.Menu;
import android.view.MenuItem;
import android.view.SurfaceView;
import android.view.View;
import android.widget.LinearLayout;


public class MainActivity extends FragmentActivity {

LinearLayout ButtonBar;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    ViewPager pager = (ViewPager) findViewById(R.id.viewPager);
    pager.setAdapter(new MyPagerAdapter(getSupportFragmentManager()));
}


private class MyPagerAdapter extends FragmentPagerAdapter {

    public MyPagerAdapter(FragmentManager fm) {
        super(fm);
    }

    @Override
    public Fragment getItem(int pos) {
        switch(pos) {
            case 0:
                return FirstFragment.newInstance("FirstFragment, Instance 1");
            case 1:
                return SecondFragment.newInstance("SecondFragment, Instance 1");
            case 2:
                return ThirdFragment.newInstance("ThirdFragment, Instance 1");
            default:
                return ThirdFragment.newInstance("ThirdFragment, Default");
        }
    }

    @Override
    public int getCount() {
        return 3;
    }
}
}

activity_main.xml

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
tools:context=".MainActivity"
android:background="#ffff">

<android.support.v4.view.ViewPager
    android:id="@+id/viewPager"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"/>
</RelativeLayout>

第二个fragment.class：

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.hardware.Camera;
import android.os.Build;
import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageButton;
import android.widget.LinearLayout;
import android.widget.TextView;

import java.io.IOException;
import java.io.OutputStream;

/**
 * Created by Gebruiker on 29-10-2014.
 */
public class SecondFragment extends Fragment {

View rootView;
ImageButton cameraShootButton;
ImageButton cameraChangeButton;
Boolean switching = false;
View.OnClickListener tapper = null;
SurfaceView cameraPreview = null;
SurfaceHolder cameraPreviewHolder = null;
Camera camera = null;
boolean inPreview = false;
boolean cameraConfigured = false;
Integer currentCamera;

public static SecondFragment newInstance(String text) {

    SecondFragment f = new SecondFragment();
    Bundle b = new Bundle();
    b.putString("msg", text);

    f.setArguments(b);

    return f;
}

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    rootView = inflater.inflate(R.layout.second_frag, container, false);


    cameraShootButton = (ImageButton) rootView.findViewById(R.id.captureB);
    cameraChangeButton = (ImageButton) rootView.findViewById(R.id.changeCameraB);
    cameraPreview = (SurfaceView) rootView.findViewById(R.id.cameraView);

    cameraPreviewHolder = cameraPreview.getHolder();
    cameraPreviewHolder.addCallback(surfaceCallback);
    cameraPreviewHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);


    tapper = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            if (v.getId() == R.id.captureB) {
                camera.takePicture(ShutterCallback, PictureCallbackRaw, null, PictureCallbackJpeg);
            } else if (v.getId() == R.id.changeCameraB) {
                if (switching == true){
                    return;
                }
                changeCamera();
            }
        }
    };

    cameraShootButton.setOnClickListener(tapper);
    cameraChangeButton.setOnClickListener(tapper);
    return rootView;
}

@Override
public void onResume() {
    super.onResume();
    camera = getCamera("back");
    currentCamera = 1;
    startPreview();
}

@Override
public void onPause() {
    if (inPreview) {
        camera.stopPreview();
    }
    camera.release();
    camera = null;
    inPreview = false;

    super.onPause();
}

private Camera.Size getBestPreviewSize(int width, int height,
                                       Camera.Parameters parameters) {
    Camera.Size result = null;

    for (Camera.Size size : parameters.getSupportedPreviewSizes()) {
        if (size.width <= width && size.height <= height) {
            if (result == null) {
                result = size;
            } else {
                int resultArea = result.width * result.height;
                int newArea = size.width * size.height;

                if (newArea > resultArea) {
                    result = size;
                }
            }
        }
    }

    return (result);
}

private void initPreview(int width, int height) {
    if (camera != null && cameraPreviewHolder.getSurface() != null) {
        try {
            camera.setPreviewDisplay(cameraPreviewHolder);
        } catch (Throwable t) {
            Log.e("PreviewDemo-surfaceCallback",
                    "Exception in setPreviewDisplay()", t);
        }

        if (!cameraConfigured) {
            Camera.Parameters parameters = camera.getParameters();
            Log.v("CAMERA", parameters.toString());
            Camera.Size size = getBestPreviewSize(width, height,
                    parameters);

            if (size != null) {
                Log.v("CameraPreviewHeight", ""+cameraPreview.getMeasuredHeight());
                Log.v("CameraRES", size.width + " " + size.height);
                parameters.setPreviewSize(size.width, size.height);
                camera.setParameters(parameters);
                cameraConfigured = true;
            }
        }
    }
}

private void startPreview() {
    if (cameraConfigured && camera != null) {
        camera.startPreview();
        inPreview = true;
        camera.setDisplayOrientation(90);
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH_MR1) {
            camera.enableShutterSound(false);
        }
    }
}

private void changeCamera() {
    switching = true;
    if (inPreview) {
        camera.stopPreview();
        camera.setPreviewCallback(null);
    }
    camera.release();
    camera = null;
    inPreview = false;
    if (currentCamera==1){
        camera = getCamera("front");
        currentCamera =2;
    }
    else{
        camera = getCamera("back");
        currentCamera = 1;
    }
    camera.setDisplayOrientation(90);
    try {
        camera.setPreviewDisplay(cameraPreviewHolder);
        cameraPreviewHolder.addCallback(surfaceCallback);
        camera.startPreview();
    } catch (IOException e) {
        e.printStackTrace();
    }

    inPreview = true;

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH_MR1) {
        camera.enableShutterSound(false);
    }
    switching = false;

}

SurfaceHolder.Callback surfaceCallback = new SurfaceHolder.Callback() {
    public void surfaceCreated(SurfaceHolder holder) {
        // no-op -- wait until surfaceChanged()
    }

    public void surfaceChanged(SurfaceHolder holder,
                               int format, int width,
                               int height) {
        initPreview(width, height);
        startPreview();
    }

    public void surfaceDestroyed(SurfaceHolder holder) {
        // no-op
    }
};

Camera.ShutterCallback ShutterCallback = new Camera.ShutterCallback() {
    public void surfaceCreated(SurfaceHolder holder) {
        // no-op -- wait until surfaceChanged()
    }

    public void surfaceChanged(SurfaceHolder holder,
                               int format, int width,
                               int height) {
        initPreview(width, height);
        startPreview();
    }

    public void surfaceDestroyed(SurfaceHolder holder) {
        // no-op
    }

    @Override
    public void onShutter() {

    }
};

Camera.PictureCallback PictureCallbackRaw = new Camera.PictureCallback() {
    public void surfaceCreated(SurfaceHolder holder) {
        // no-op -- wait until surfaceChanged()
    }

    public void surfaceChanged(SurfaceHolder holder,
                               int format, int width,
                               int height) {
        initPreview(width, height);
        startPreview();
    }

    public void surfaceDestroyed(SurfaceHolder holder) {
        // no-op
    }

    @Override
    public void onPictureTaken(byte[] data, Camera camera) {

    }
};

Camera.PictureCallback PictureCallbackJpeg = new Camera.PictureCallback() {
    public void surfaceCreated(SurfaceHolder holder) {
        // no-op -- wait until surfaceChanged()
    }

    public void surfaceChanged(SurfaceHolder holder,
                               int format, int width,
                               int height) {
        initPreview(width, height);
        startPreview();
    }

    public void surfaceDestroyed(SurfaceHolder holder) {
        // no-op
    }

    @Override
    public void onPictureTaken(byte[] byteData, Camera camera) {
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inSampleSize = 5;
        OutputStream bos = null;
        Bitmap m = BitmapFactory.decodeByteArray(byteData, 0, byteData.length, options);

        //m.compress(Bitmap.CompressFormat.PNG, 75, bos);
        //Log.v("CAPTURED", ""+bos);
    }
};

private Camera getCamera(String getCamera) {
    int cameraCount = 0;
    Camera cam = null;
    Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
    cameraCount = Camera.getNumberOfCameras();
    for (int camIdx = 0; camIdx < cameraCount; camIdx++) {
        Camera.getCameraInfo(camIdx, cameraInfo);
        if ((cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) && (getCamera == "front")) {
            try {
                cam = Camera.open(camIdx);
            } catch (RuntimeException e) {
                Log.e("TEST", "Camera failed to open: " + e.getLocalizedMessage());
            }
        }
        else if ((cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_BACK) && (getCamera == "back")) {
            try {
                cam = Camera.open(camIdx);
            } catch (RuntimeException e) {
                Log.e("TEST", "Camera failed to open: " + e.getLocalizedMessage());
            }
        }
    }
    return cam;
}


}

导入android.graphics.Bitmap；
导入android.graphics.BitmapFactory；
导入android.hardware.Camera；
导入android.os.Build；
导入android.os.Bundle；
导入android.support.v4.app.Fragment；
导入android.util.Log；
导入android.view.LayoutInflater；
导入android.view.SurfaceHolder；
导入android.view.SurfaceView；
导入android.view.view；
导入android.view.ViewGroup；
导入android.widget.ImageButton；
导入android.widget.LinearLayout；
导入android.widget.TextView；
导入java.io.IOException；
导入java.io.OutputStream；
/**
*由Gebruiker于2014年10月29日创建。
*/
公共类SecondFragment扩展了片段{
视图根视图；
图像按钮摄像按钮；
图像按钮摄像机切换按钮；
布尔转换=假；
View.OnClickListener tapper=null；
SurfaceView cameraPreview=null；
SurfaceHolder CameraPreviewWholder=null；
摄像头=空；
布尔inPreview=false；
布尔cameraConfigured=false；
整型摄像机；
公共静态SecondFragment newInstance（字符串文本）{
SecondFragment f=新的SecondFragment（）；
Bundle b=新Bundle（）；
b、 putString（“msg”，文本）；
f、 设置参数（b）；
返回f；
}
@凌驾
CreateView上的公共视图（布局、充气机、视图组容器、捆绑包保存状态）{
rootView=充气机。充气（右布局第二框架，容器，假）；
cameraShootButton=（ImageButton）rootView.findViewById（R.id.captureB）；
cameraChangeButton=（ImageButton）rootView.findViewById（R.id.changeCameraB）；
cameraPreview=（SurfaceView）rootView.findviewbyd（R.id.cameraView）；
CamerapReviewWholder=cameraPreview.getHolder（）；
CamerapReviewWholder.addCallback（surfaceCallback）；
CamerapReviewWholder.setType（SurfaceHolder.SURFACE_TYPE_PUSH_缓冲区）；
tapper=newview.OnClickListener（）{
@凌驾
公共void onClick（视图v）{
if（v.getId（）==R.id.captureB）{
照相/摄像（ShutterCallback、PictureCallbackRaw、null、PictureCallbackJpeg）；
}else if（v.getId（）==R.id.changeCameraB）{
如果（切换==真）{
返回；
}
更换摄像头（）；
}
}
};
cameraShootButton.setOnClickListener（tapper）；
cameraChangeButton.setOnClickListener（tapper）；
返回rootView；
}
@凌驾
恢复时公开作废（）{
super.onResume（）；
摄像头=获取摄像头（“背面”）；
currentCamera=1；
startPreview（）；
}
@凌驾
公共无效暂停（）{
如果（审查）{
camera.stopPreview（）；
}
相机。释放（）；
摄像机=零；
inPreview=false；
super.onPause（）；
}
私人相机。大小getBestPreviewSize（整数宽度，整数高度，
摄像机（参数）{
Camera.Size结果=null；
对于（Camera.Size:parameters.getSupportedPreviewSizes（））{
如果（size.width=Build.VERSION\u code.ICE\u SANDWICH\u MR1）{
摄像头。启用快门声音（错误）；
}
}
}
私人摄像机（）{
切换=真；
如果（审查）{
camera.stopPreview（）；
camera.setPreviewCallback（空）；
}
相机。释放（）；
摄像机=零；
inPreview=false；
如果（currentCamera==1）{
摄像头=获取摄像头（“前”）；
currentCamera=2；
}
否则{
摄像头=获取摄像头（“背面”）；
currentCamera=1；
}
摄像头。设置显示方向（90）；
试一试{
camera.setPreviewDisplay（CameraPreviewWholder）；
CamerapReviewWholder.addCallback（surfaceCallback）；
camera.startPreview（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
inPreview=true；
如果（Build.VERSION.SDK\u INT>=Build.VERSION\u代码.冰淇淋\u三明治\u MR1）{
摄像头。启用快门声音（错误）；
}
切换=错误；
}
SurfaceHolder.Callback surfaceCallback=新建SurfaceHolder.Callback（）{
已创建的公共空白表面（表面持有人）{
//无操作--等待surfaceChanged（）完成
}
公共空间表面变更（表面持有人，
整数格式，整数宽度，
整数高度）{
初始预览（宽度、高度）；
startPreview（）；
}
公共空间表面覆盖（表面覆盖物持有人）{
//无操作
}
};
Camera.ShutterCallback ShutterCallback=新建Camera.ShutterCallback（）{
已创建的公共空白表面（表面持有人）{
//无操作--等待surfaceChanged（）完成
}
公共空间表面变更（表面持有人，
整数格式，整数宽度，
整数高度）{
初始预览（宽度、高度）；
startPreview（）；
}
公共空间表面覆盖（表面覆盖物持有人）{
//无操作
}
@凌驾
公共空间{
}
};
Camera.PictureCallback PictureCallbackRaw=新建Camera.PictureCallback（）{
已创建的公共空白表面（表面持有人）{
//不，等等
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent">

<android.view.SurfaceView
    android:id="@+id/cameraView"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

<LinearLayout
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:orientation="horizontal"
    android:layout_alignParentBottom="true">

    <LinearLayout
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:gravity="center">

        <ImageButton
            android:id="@+id/flitserB"
            android:layout_width="30dp"
            android:layout_height="70dp"
            android:scaleType="fitCenter"
            android:src="@drawable/flash"
            android:background="@null"/>
    </LinearLayout>

    <LinearLayout
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:gravity="center">
        <ImageButton
            android:id="@+id/captureB"
            android:layout_width="70dp"
            android:layout_height="70dp"
            android:scaleType="fitCenter"
            android:src="@drawable/camerashoot"
            android:background="@null"/>
    </LinearLayout>

    <LinearLayout
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:gravity="center">
        <ImageButton
            android:id="@+id/changeCameraB"
            android:layout_width="30dp"
            android:layout_height="70dp"
            android:scaleType="fitCenter"
            android:src="@drawable/camerachange"
            android:background="@null"/>

    </LinearLayout>

</LinearLayout>


</RelativeLayout>

<uses-permission android:name="android.permission.CAMERA" />