title: App is crashing when loading new activity
body: <p>Hi im trying to load another acivity on my class without activity extension so I used another class that has an activity this is my code for the <strong>MAINACTIVITY</strong></p>
  
  <pre><code>
  
  
  
    public void onCreate(Bundle savedInstanceState) {
  
  
      super.onCreate(savedInstanceState);
      setContentView(R.layout.activity_camera);
      if (null == savedInstanceState) {
        getFragmentManager()
                .beginTransaction()
                .replace(R.id.container, Camera2BasicFragment.newInstance())
                .commit();
  
  
      }
  
  
    }
  
    public void loadScanresults2() {
  
      Intent intent1 = new Intent(this, resultsActvitity.class);
      intent1.putExtra("HighScanResults", GlobalVars.scanresHigh);
      intent1.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK |
              Intent.FLAG_ACTIVITY_SINGLE_TOP);
      **startActivity(intent1);**
  
  
    }
  
  </code></pre>
  
  <p>and this is the class for ImageCLassifier</p>
  
  <pre><code>
  
  public class ImageClassifier {
  
  
  
  
    private static final String TAG = "TfLiteCameraDemo";
  
  
    private static final String MODEL_PATH = "graph.lite";
  
  
    private static final String LABEL_PATH = "labels.txt";
  
  
    private static final int RESULTS_TO_SHOW = 3;
  
  
    private static final int DIM_BATCH_SIZE = 1;
  
    private static final int DIM_PIXEL_SIZE = 3;
  
    static final int DIM_IMG_SIZE_X = 224;
    static final int DIM_IMG_SIZE_Y = 224;
  
    private static final int IMAGE_MEAN = 128;
    private static final float IMAGE_STD = 128.0f;
  
    private int[] intValues = new int[DIM_IMG_SIZE_X * DIM_IMG_SIZE_Y];
  
    private Interpreter tflite;
  
    private List&lt;String&gt; labelList;
  
    /** A ByteBuffer to hold image data, to be feed into Tensorflow Lite as inputs. */
    private ByteBuffer imgData = null;
  
  
    private float[][] labelProbArray = null;
  
    private float[][] filterLabelProbArray = null;
    private static final int FILTER_STAGES = 3;
    private static final float FILTER_FACTOR = 0.4f;
  
    private PriorityQueue&lt;Map.Entry&lt;String, Float&gt;&gt; sortedLabels =
        new PriorityQueue&lt;&gt;(
            RESULTS_TO_SHOW,
            new Comparator&lt;Map.Entry&lt;String, Float&gt;&gt;() {
              @Override
              public int compare(Map.Entry&lt;String, Float&gt; o1, Map.Entry&lt;String, Float&gt; o2) {
                return (o1.getValue()).compareTo(o2.getValue());
              }
            });
  
  
    ImageClassifier(Activity activity) throws IOException {
      tflite = new Interpreter(loadModelFile(activity));
      labelList = loadLabelList(activity);
      imgData =
          ByteBuffer.allocateDirect(
              4 * DIM_BATCH_SIZE * DIM_IMG_SIZE_X * DIM_IMG_SIZE_Y * DIM_PIXEL_SIZE);
      imgData.order(ByteOrder.nativeOrder());
      labelProbArray = new float[1][labelList.size()];
      filterLabelProbArray = new float[FILTER_STAGES][labelList.size()];
      Log.d(TAG, "Created a Tensorflow Lite Image Classifier.");
    }
  
  
    String classifyFrame(Bitmap bitmap) {
      if (tflite == null) {
        Log.e(TAG, "Image classifier has not been initialized; Skipped.");
        return "Uninitialized Classifier.";
      }
      convertBitmapToByteBuffer(bitmap);
      // Here's where the magic happens!!!
      long startTime = SystemClock.uptimeMillis();
      tflite.run(imgData, labelProbArray);
      long endTime = SystemClock.uptimeMillis();
      Log.d(TAG, "Timecost to run model inference: " + Long.toString(endTime - startTime));
  
      // smooth the results
      applyFilter();
  
      // print the results
      String textToShow = printTopKLabels();
      textToShow = Long.toString(endTime - startTime) + "ms" + textToShow;
      return textToShow;
    }
  
    void applyFilter(){
      int num_labels =  labelList.size();
  
      // Low pass filter `labelProbArray` into the first stage of the filter.
      for(int j=0; j&lt;num_labels; ++j){
        filterLabelProbArray[0][j] += FILTER_FACTOR*(labelProbArray[0][j] -
                                                     filterLabelProbArray[0][j]);
      }
      // Low pass filter each stage into the next.
      for (int i=1; i&lt;FILTER_STAGES; ++i){
        for(int j=0; j&lt;num_labels; ++j){
          filterLabelProbArray[i][j] += FILTER_FACTOR*(
                  filterLabelProbArray[i-1][j] -
                  filterLabelProbArray[i][j]);
  
        }
      }
  
      // Copy the last stage filter output back to `labelProbArray`.
      for(int j=0; j&lt;num_labels; ++j){
        labelProbArray[0][j] = filterLabelProbArray[FILTER_STAGES-1][j];
      }
    }
  
    /** Closes tflite to release resources. */
    public void close() {
      tflite.close();
      tflite = null;
    }
  
    /** Reads label list from Assets. */
    private List&lt;String&gt; loadLabelList(Activity activity) throws IOException {
      List&lt;String&gt; labelList = new ArrayList&lt;String&gt;();
      BufferedReader reader =
          new BufferedReader(new InputStreamReader(activity.getAssets().open(LABEL_PATH)));
      String line;
      while ((line = reader.readLine()) != null) {
        labelList.add(line);
      }
      reader.close();
      return labelList;
    }
  
    /** Memory-map the model file in Assets. */
    private MappedByteBuffer loadModelFile(Activity activity) throws IOException {
      AssetFileDescriptor fileDescriptor = activity.getAssets().openFd(MODEL_PATH);
      FileInputStream inputStream = new FileInputStream(fileDescriptor.getFileDescriptor());
      FileChannel fileChannel = inputStream.getChannel();
      long startOffset = fileDescriptor.getStartOffset();
      long declaredLength = fileDescriptor.getDeclaredLength();
      return fileChannel.map(FileChannel.MapMode.READ_ONLY, startOffset, declaredLength);
    }
  
    /** Writes Image data into a {@code ByteBuffer}. */
    private void convertBitmapToByteBuffer(Bitmap bitmap) {
      if (imgData == null) {
        return;
      }
      imgData.rewind();
      bitmap.getPixels(intValues, 0, bitmap.getWidth(), 0, 0, bitmap.getWidth(), bitmap.getHeight());
      // Convert the image to floating point.
      int pixel = 0;
      long startTime = SystemClock.uptimeMillis();
      for (int i = 0; i &lt; DIM_IMG_SIZE_X; ++i) {
        for (int j = 0; j &lt; DIM_IMG_SIZE_Y; ++j) {
          final int val = intValues[pixel++];
          imgData.putFloat((((val &gt;&gt; 16) &amp; 0xFF)-IMAGE_MEAN)/IMAGE_STD);
          imgData.putFloat((((val &gt;&gt; 8) &amp; 0xFF)-IMAGE_MEAN)/IMAGE_STD);
          imgData.putFloat((((val) &amp; 0xFF)-IMAGE_MEAN)/IMAGE_STD);
        }
      }
      long endTime = SystemClock.uptimeMillis();
      Log.d(TAG, "Timecost to put values into ByteBuffer: " + Long.toString(endTime - startTime));
    }
  
    /** Prints top-K labels, to be shown in UI as the results. */
    private String printTopKLabels() {
      for (int i = 0; i &lt; labelList.size(); ++i) {
        sortedLabels.add(
                new AbstractMap.SimpleEntry&lt;&gt;(labelList.get(i), labelProbArray[0][i]));
        if (sortedLabels.size() &gt; RESULTS_TO_SHOW) {
          sortedLabels.poll();
        }
  
      }
  
  
      String textToShow = "";
  
     /* final int size = sortedLabels.size();
      for (int i = 0; i &lt; size; ++i) {
  */
  
  
      Map.Entry&lt;String, Float&gt; label = sortedLabels.poll();
  
      //textToShow = String.format("\nHighest: %4.2f",labelProbArray[0][1]) + textToShow;
      textToShow = String.format("\nHighest: %4.2f", labelProbArray[0][1]) + textToShow;
  
      int list1 = 1;
      float f = labelProbArray[0][1];
      GlobalVars.reshigh = f;
      if (f &gt; 0.95) {
        GlobalVars.scanresHigh = textToShow;
        GlobalVars.intentSet = true;
        textToShow = String.format("\nHighest: %4.2f %s ", labelProbArray[0][1], labelList.get(list1)) + textToShow;
        CameraActivity loadres = new CameraActivity();
        loadres.loadScanresults2();
  
  
  
  
  
  
      }
  
      return textToShow;
  
  
    }
  
  
  
  
  
    }
  
  
  </code></pre>
  
  <p>for the CameraFragment</p>
  
  <pre><code>
  
  /** Basic fragments for the Camera. */
  public class Camera2BasicFragment extends Fragment
      implements FragmentCompat.OnRequestPermissionsResultCallback {
  
  
  
    /** Tag for the {@link Log}. */
    private static final String TAG = "TfLiteCameraDemo";
  
    private static final String FRAGMENT_DIALOG = "dialog";
  
    private static final String HANDLE_THREAD_NAME = "CameraBackground";
  
    private static final int PERMISSIONS_REQUEST_CODE = 1;
  
    private final Object lock = new Object();
    private boolean runClassifier = false;
    private boolean checkedPermissions = false;
    private TextView textView;
    private ImageClassifier classifier;
  
    /** Max preview width that is guaranteed by Camera2 API */
    private static final int MAX_PREVIEW_WIDTH = 1920;
  
    /** Max preview height that is guaranteed by Camera2 API */
    private static final int MAX_PREVIEW_HEIGHT = 1080;
  
    /**
     * {@link TextureView.SurfaceTextureListener} handles several lifecycle events on a {@link
     * TextureView}.
     */
    private final TextureView.SurfaceTextureListener surfaceTextureListener =
        new TextureView.SurfaceTextureListener() {
  
          @Override
          public void onSurfaceTextureAvailable(SurfaceTexture texture, int width, int height) {
            openCamera(width, height);
          }
  
          @Override
          public void onSurfaceTextureSizeChanged(SurfaceTexture texture, int width, int height) {
            configureTransform(width, height);
          }
  
          @Override
          public boolean onSurfaceTextureDestroyed(SurfaceTexture texture) {
            return true;
          }
  
          @Override
          public void onSurfaceTextureUpdated(SurfaceTexture texture) {}
        };
  
    /** ID of the current {@link CameraDevice}. */
    private String cameraId;
  
  
    private AutoFitTextureView textureView;
  
    private CameraCaptureSession captureSession;
  
  
    private CameraDevice cameraDevice;
  
  
    private Size previewSize;
  
  
    private final CameraDevice.StateCallback stateCallback =
        new CameraDevice.StateCallback() {
  
          @Override
          public void onOpened(@NonNull CameraDevice currentCameraDevice) {
            // This method is called when the camera is opened.  We start camera preview here.
            cameraOpenCloseLock.release();
            cameraDevice = currentCameraDevice;
            createCameraPreviewSession();
          }
  
          @Override
          public void onDisconnected(@NonNull CameraDevice currentCameraDevice) {
            cameraOpenCloseLock.release();
            currentCameraDevice.close();
            cameraDevice = null;
          }
  
          @Override
          public void onError(@NonNull CameraDevice currentCameraDevice, int error) {
            cameraOpenCloseLock.release();
            currentCameraDevice.close();
            cameraDevice = null;
            Activity activity = getActivity();
            if (null != activity) {
              activity.finish();
            }
          }
        };
  
  
    private HandlerThread backgroundThread;
  
  
    private Handler backgroundHandler;
  
  
    private ImageReader imageReader;
  
  
    private CaptureRequest.Builder previewRequestBuilder;
  
  
    private CaptureRequest previewRequest;
  
  
    private Semaphore cameraOpenCloseLock = new Semaphore(1);
  
  
    private CameraCaptureSession.CaptureCallback captureCallback =
        new CameraCaptureSession.CaptureCallback() {
  
          @Override
          public void onCaptureProgressed(
              @NonNull CameraCaptureSession session,
              @NonNull CaptureRequest request,
              @NonNull CaptureResult partialResult) {}
  
          @Override
          public void onCaptureCompleted(
              @NonNull CameraCaptureSession session,
              @NonNull CaptureRequest request,
              @NonNull TotalCaptureResult result) {}
        };
  
  
    private void showToast(final String text) {
      final Activity activity = getActivity();
      if (activity != null) {
        activity.runOnUiThread(
            new Runnable() {
              @Override
              public void run() {
                textView.setText(text);
              }
            });
      }
    }
  
  
    private static Size chooseOptimalSize(
        Size[] choices,
        int textureViewWidth,
        int textureViewHeight,
        int maxWidth,
        int maxHeight,
        Size aspectRatio) {
  
      // Collect the supported resolutions that are at least as big as the preview Surface
      List&lt;Size&gt; bigEnough = new ArrayList&lt;&gt;();
      // Collect the supported resolutions that are smaller than the preview Surface
      List&lt;Size&gt; notBigEnough = new ArrayList&lt;&gt;();
      int w = aspectRatio.getWidth();
      int h = aspectRatio.getHeight();
      for (Size option : choices) {
        if (option.getWidth() &lt;= maxWidth
            &amp;&amp; option.getHeight() &lt;= maxHeight
            &amp;&amp; option.getHeight() == option.getWidth() * h / w) {
          if (option.getWidth() &gt;= textureViewWidth &amp;&amp; option.getHeight() &gt;= textureViewHeight) {
            bigEnough.add(option);
          } else {
            notBigEnough.add(option);
          }
        }
      }
  
      // Pick the smallest of those big enough. If there is no one big enough, pick the
      // largest of those not big enough.
      if (bigEnough.size() &gt; 0) {
        return Collections.min(bigEnough, new CompareSizesByArea());
      } else if (notBigEnough.size() &gt; 0) {
        return Collections.max(notBigEnough, new CompareSizesByArea());
      } else {
        Log.e(TAG, "Couldn't find any suitable preview size");
        return choices[0];
      }
    }
  
    public static Camera2BasicFragment newInstance() {
      return new Camera2BasicFragment();
    }
  
  
    @Override
    public View onCreateView(
        LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
      return inflater.inflate(R.layout.fragment_camera2_basic, container, false);
    }
  
    /** Connect the buttons to their event handler. */
    @Override
    public void onViewCreated(final View view, Bundle savedInstanceState) {
      textureView = (AutoFitTextureView) view.findViewById(R.id.texture);
      textView = (TextView) view.findViewById(R.id.text);
    }
  
  
    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
      super.onActivityCreated(savedInstanceState);
      try {
        classifier = new ImageClassifier(getActivity());
      } catch (IOException e) {
        Log.e(TAG, "Failed to initialize an image classifier.");
      }
      startBackgroundThread();
    }
  
    @Override
    public void onResume() {
      super.onResume();
      startBackgroundThread();
  
  
      if (textureView.isAvailable()) {
        openCamera(textureView.getWidth(), textureView.getHeight());
      } else {
        textureView.setSurfaceTextureListener(surfaceTextureListener);
      }
    }
  
    @Override
    public void onPause() {
      closeCamera();
      stopBackgroundThread();
      super.onPause();
    }
  
    @Override
    public void onDestroy() {
      classifier.close();
      super.onDestroy();
    }
  
  
    private void setUpCameraOutputs(int width, int height) {
      Activity activity = getActivity();
      CameraManager manager = (CameraManager) activity.getSystemService(Context.CAMERA_SERVICE);
      try {
        for (String cameraId : manager.getCameraIdList()) {
          CameraCharacteristics characteristics = manager.getCameraCharacteristics(cameraId);
  
          // We don't use a front facing camera in this sample.
          Integer facing = characteristics.get(CameraCharacteristics.LENS_FACING);
          if (facing != null &amp;&amp; facing == CameraCharacteristics.LENS_FACING_FRONT) {
            continue;
          }
  
          StreamConfigurationMap map =
              characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
          if (map == null) {
            continue;
          }
  
  
          Size largest =
              Collections.max(
                  Arrays.asList(map.getOutputSizes(ImageFormat.JPEG)), new CompareSizesByArea());
          imageReader =
              ImageReader.newInstance(
                  largest.getWidth(), largest.getHeight(), ImageFormat.JPEG, /*maxImages*/ 2);
  
  
          int displayRotation = activity.getWindowManager().getDefaultDisplay().getRotation();
  
          int sensorOrientation = characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);
          boolean swappedDimensions = false;
          switch (displayRotation) {
            case Surface.ROTATION_0:
            case Surface.ROTATION_180:
              if (sensorOrientation == 90 || sensorOrientation == 270) {
                swappedDimensions = true;
              }
              break;
            case Surface.ROTATION_90:
            case Surface.ROTATION_270:
              if (sensorOrientation == 0 || sensorOrientation == 180) {
                swappedDimensions = true;
              }
              break;
            default:
              Log.e(TAG, "Display rotation is invalid: " + displayRotation);
          }
  
          Point displaySize = new Point();
          activity.getWindowManager().getDefaultDisplay().getSize(displaySize);
          int rotatedPreviewWidth = width;
          int rotatedPreviewHeight = height;
          int maxPreviewWidth = displaySize.x;
          int maxPreviewHeight = displaySize.y;
  
          if (swappedDimensions) {
            rotatedPreviewWidth = height;
            rotatedPreviewHeight = width;
            maxPreviewWidth = displaySize.y;
            maxPreviewHeight = displaySize.x;
          }
  
          if (maxPreviewWidth &gt; MAX_PREVIEW_WIDTH) {
            maxPreviewWidth = MAX_PREVIEW_WIDTH;
          }
  
          if (maxPreviewHeight &gt; MAX_PREVIEW_HEIGHT) {
            maxPreviewHeight = MAX_PREVIEW_HEIGHT;
          }
  
          previewSize =
              chooseOptimalSize(
                  map.getOutputSizes(SurfaceTexture.class),
                  rotatedPreviewWidth,
                  rotatedPreviewHeight,
                  maxPreviewWidth,
                  maxPreviewHeight,
                  largest);
  
          // We fit the aspect ratio of TextureView to the size of preview we picked.
          int orientation = getResources().getConfiguration().orientation;
          if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
            textureView.setAspectRatio(previewSize.getWidth(), previewSize.getHeight());
          } else {
            textureView.setAspectRatio(previewSize.getHeight(), previewSize.getWidth());
          }
  
          this.cameraId = cameraId;
          return;
        }
      } catch (CameraAccessException e) {
        e.printStackTrace();
      } catch (NullPointerException e) {
        // Currently an NPE is thrown when the Camera2API is used but not supported on the
        // device this code runs.
        ErrorDialog.newInstance(getString(R.string.camera_error))
            .show(getChildFragmentManager(), FRAGMENT_DIALOG);
      }
    }
  
    private String[] getRequiredPermissions() {
      Activity activity = getActivity();
      try {
        PackageInfo info =
            activity
                .getPackageManager()
                .getPackageInfo(activity.getPackageName(), PackageManager.GET_PERMISSIONS);
        String[] ps = info.requestedPermissions;
        if (ps != null &amp;&amp; ps.length &gt; 0) {
          return ps;
        } else {
          return new String[0];
        }
      } catch (Exception e) {
        return new String[0];
      }
    }
  
    /** Opens the camera specified by {@link Camera2BasicFragment#cameraId}. */
    private void openCamera(int width, int height) {
      if (!checkedPermissions &amp;&amp; !allPermissionsGranted()) {
        FragmentCompat.requestPermissions(this, getRequiredPermissions(), PERMISSIONS_REQUEST_CODE);
        return;
      } else {
        checkedPermissions = true;
      }
      setUpCameraOutputs(width, height);
      configureTransform(width, height);
      Activity activity = getActivity();
      CameraManager manager = (CameraManager) activity.getSystemService(Context.CAMERA_SERVICE);
      try {
        if (!cameraOpenCloseLock.tryAcquire(2500, TimeUnit.MILLISECONDS)) {
          throw new RuntimeException("Time out waiting to lock camera opening.");
        }
        manager.openCamera(cameraId, stateCallback, backgroundHandler);
      } catch (CameraAccessException e) {
        e.printStackTrace();
      } catch (InterruptedException e) {
        throw new RuntimeException("Interrupted while trying to lock camera opening.", e);
      }
    }
  
    private boolean allPermissionsGranted() {
      for (String permission : getRequiredPermissions()) {
        if (ContextCompat.checkSelfPermission(getActivity(), permission)
            != PackageManager.PERMISSION_GRANTED) {
          return false;
        }
      }
      return true;
    }
  
    @Override
    public void onRequestPermissionsResult(
        int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
      super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    }
  
    /** Closes the current {@link CameraDevice}. */
    private void closeCamera() {
      try {
        cameraOpenCloseLock.acquire();
        if (null != captureSession) {
          captureSession.close();
          captureSession = null;
        }
        if (null != cameraDevice) {
          cameraDevice.close();
          cameraDevice = null;
        }
        if (null != imageReader) {
          imageReader.close();
          imageReader = null;
        }
      } catch (InterruptedException e) {
        throw new RuntimeException("Interrupted while trying to lock camera closing.", e);
      } finally {
        cameraOpenCloseLock.release();
      }
    }
  
    /** Starts a background thread and its {@link Handler}. */
    private void startBackgroundThread() {
      backgroundThread = new HandlerThread(HANDLE_THREAD_NAME);
      backgroundThread.start();
      backgroundHandler = new Handler(backgroundThread.getLooper());
      synchronized (lock) {
        runClassifier = true;
      }
      backgroundHandler.post(periodicClassify);
    }
  
    /** Stops the background thread and its {@link Handler}. */
    private void stopBackgroundThread() {
      backgroundThread.quitSafely();
      try {
        backgroundThread.join();
        backgroundThread = null;
        backgroundHandler = null;
        synchronized (lock) {
          runClassifier = false;
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  
    /** Takes photos and classify them periodically. */
    private Runnable periodicClassify =
        new Runnable() {
          @Override
          public void run() {
            synchronized (lock) {
              if (runClassifier) {
                classifyFrame();
              }
            }
            backgroundHandler.post(periodicClassify);
          }
        };
  
    /** Creates a new {@link CameraCaptureSession} for camera preview. */
    private void createCameraPreviewSession() {
      try {
        SurfaceTexture texture = textureView.getSurfaceTexture();
        assert texture != null;
  
        // We configure the size of default buffer to be the size of camera preview we want.
        texture.setDefaultBufferSize(previewSize.getWidth(), previewSize.getHeight());
  
        // This is the output Surface we need to start preview.
        Surface surface = new Surface(texture);
  
        // We set up a CaptureRequest.Builder with the output Surface.
        previewRequestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
        previewRequestBuilder.addTarget(surface);
  
        // Here, we create a CameraCaptureSession for camera preview.
        cameraDevice.createCaptureSession(
            Arrays.asList(surface),
            new CameraCaptureSession.StateCallback() {
  
              @Override
              public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) {
                // The camera is already closed
                if (null == cameraDevice) {
                  return;
                }
  
                // When the session is ready, we start displaying the preview.
                captureSession = cameraCaptureSession;
                try {
                  // Auto focus should be continuous for camera preview.
                  previewRequestBuilder.set(
                      CaptureRequest.CONTROL_AF_MODE,
                      CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
  
                  // Finally, we start displaying the camera preview.
                  previewRequest = previewRequestBuilder.build();
                  captureSession.setRepeatingRequest(
                      previewRequest, captureCallback, backgroundHandler);
                } catch (CameraAccessException e) {
                  e.printStackTrace();
                }
              }
  
              @Override
              public void onConfigureFailed(@NonNull CameraCaptureSession cameraCaptureSession) {
                showToast("Failed");
              }
            },
            null);
      } catch (CameraAccessException e) {
        e.printStackTrace();
      }
    }
  
    /**
     * Configures the necessary {@link android.graphics.Matrix} transformation to `textureView`. This
     * method should be called after the camera preview size is determined in setUpCameraOutputs and
     * also the size of `textureView` is fixed.
     *
     * @param viewWidth The width of `textureView`
     * @param viewHeight The height of `textureView`
     */
    private void configureTransform(int viewWidth, int viewHeight) {
      Activity activity = getActivity();
      if (null == textureView || null == previewSize || null == activity) {
        return;
      }
      int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();
      Matrix matrix = new Matrix();
      RectF viewRect = new RectF(0, 0, viewWidth, viewHeight);
      RectF bufferRect = new RectF(0, 0, previewSize.getHeight(), previewSize.getWidth());
      float centerX = viewRect.centerX();
      float centerY = viewRect.centerY();
      if (Surface.ROTATION_90 == rotation || Surface.ROTATION_270 == rotation) {
        bufferRect.offset(centerX - bufferRect.centerX(), centerY - bufferRect.centerY());
        matrix.setRectToRect(viewRect, bufferRect, Matrix.ScaleToFit.FILL);
        float scale =
            Math.max(
                (float) viewHeight / previewSize.getHeight(),
                (float) viewWidth / previewSize.getWidth());
        matrix.postScale(scale, scale, centerX, centerY);
        matrix.postRotate(90 * (rotation - 2), centerX, centerY);
      } else if (Surface.ROTATION_180 == rotation) {
        matrix.postRotate(180, centerX, centerY);
      }
      textureView.setTransform(matrix);
    }
  
    /** Classifies a frame from the preview stream. */
    private void classifyFrame() {
      if (classifier == null || getActivity() == null || cameraDevice == null) {
        showToast("Uninitialized Classifier or invalid context.");
        return;
      }
      Bitmap bitmap =
          textureView.getBitmap(ImageClassifier.DIM_IMG_SIZE_X, ImageClassifier.DIM_IMG_SIZE_Y);
      String textToShow = classifier.classifyFrame(bitmap);
      bitmap.recycle();
      showToast(textToShow);
    }
  
    /** Compares two {@code Size}s based on their areas. */
    private static class CompareSizesByArea implements Comparator&lt;Size&gt; {
  
      @Override
      public int compare(Size lhs, Size rhs) {
        // We cast here to ensure the multiplications won't overflow
        return Long.signum(
            (long) lhs.getWidth() * lhs.getHeight() - (long) rhs.getWidth() * rhs.getHeight());
      }
    }
  
    /** Shows an error message dialog. */
    public static class ErrorDialog extends DialogFragment {
  
      private static final String ARG_MESSAGE = "message";
  
      public static ErrorDialog newInstance(String message) {
        ErrorDialog dialog = new ErrorDialog();
        Bundle args = new Bundle();
        args.putString(ARG_MESSAGE, message);
        dialog.setArguments(args);
        return dialog;
      }
  
      @Override
      public Dialog onCreateDialog(Bundle savedInstanceState) {
        final Activity activity = getActivity();
        return new AlertDialog.Builder(activity)
            .setMessage(getArguments().getString(ARG_MESSAGE))
            .setPositiveButton(
                android.R.string.ok,
                new DialogInterface.OnClickListener() {
                  @Override
                  public void onClick(DialogInterface dialogInterface, int i) {
                    activity.finish();
                  }
                })
            .create();
      }
    }
  
  }
  
  
  </code></pre>
  
  <p>and this is the error that im getting whenever I run debug </p>
  
  <pre><code>java.lang.NullPointerException: Attempt to invoke virtual method 'java.lang.String android.content.Context.getPackageName()' on a null object reference
          at android.content.ContextWrapper.getPackageName(ContextWrapper.java:132)
          at android.content.ComponentName.&lt;init&gt;(ComponentName.java:128)
          at android.content.Intent.&lt;init&gt;(Intent.java:4868)
          at com.example.android.tflitecamerademo.loadScanresults.loadScanresults2(loadScanresults.java:11)
          at com.example.android.tflitecamerademo.ImageClassifier.printTopKLabels(ImageClassifier.java:246)
          at com.example.android.tflitecamerademo.ImageClassifier.classifyFrame(ImageClassifier.java:134)
          at com.example.android.tflitecamerademo.Camera2BasicFragment.classifyFrame(Camera2BasicFragment.java:663)
          at com.example.android.tflitecamerademo.Camera2BasicFragment.access$900(Camera2BasicFragment.java:69)
          at com.example.android.tflitecamerademo.Camera2BasicFragment$5.run(Camera2BasicFragment.java:558)
          at android.os.Handler.handleCallback(Handler.java:751)
          at android.os.Handler.dispatchMessage(Handler.java:95)
          at android.os.Looper.loop(Looper.java:154)
          at android.os.HandlerThread.run(HandlerThread.java:61)
  </code></pre>
  
  <p>am I doing something wrong? thanks guys</p>
  
  <p>EDIT: It's still having the same errors</p>