content: package com.reactnativedocumentscannerandroid.helpers;
  
  import android.content.ContentValues;
  import android.content.Context;
  import android.content.SharedPreferences;
  import android.content.pm.PackageInfo;
  import android.content.pm.PackageManager;
  import android.graphics.Bitmap;
  import android.graphics.BitmapFactory;
  import android.graphics.Point;
  import android.preference.PreferenceManager;
  import android.provider.MediaStore;
  import android.view.Display;
  import android.view.WindowManager;
  
  import java.io.File;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Comparator;
  import java.util.Locale;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import javax.microedition.khronos.egl.EGL10;
  import javax.microedition.khronos.egl.EGLConfig;
  import javax.microedition.khronos.egl.EGLContext;
  import javax.microedition.khronos.egl.EGLDisplay;
  
  public class Utils {
  
      private final SharedPreferences mSharedPref;
      private Context _context;
  
      // constructor
      public Utils(Context context) {
          this._context = context;
          mSharedPref = PreferenceManager.getDefaultSharedPreferences(context);
      }
  
      /*
       * Reading file paths from SDCard
       */
      public ArrayList<String> getFilePaths() {
          ArrayList<String> filePaths = new ArrayList<String>();
  
          File directory = new File(
                  android.os.Environment.getExternalStorageDirectory()
                          + File.separator + mSharedPref.getString("storage_folder","OpenNoteScanner"));
  
          // check for directory
          if (directory.isDirectory()) {
              // getting list of file paths
              File[] listFiles = directory.listFiles();
  
              Arrays.sort(listFiles, new Comparator<File>() {
                  public int compare(File f1, File f2) {
                      return f2.getName().compareTo(f1.getName());
                  }
              });
  
              // Check for count
              if (listFiles.length > 0) {
  
                  // loop through all files
                  for (int i = 0; i < listFiles.length; i++) {
  
                      // get file path
                      String filePath = listFiles[i].getAbsolutePath();
  
                      // check for supported file extension
                      if (IsSupportedFile(filePath)) {
                          // Add image path to array list
                          filePaths.add(filePath);
                      }
                  }
              }
          }
  
          return filePaths;
      }
  
      /*
       * Check supported file extensions
       *
       * @returns boolean
       */
      private boolean IsSupportedFile(String filePath) {
          String ext = filePath.substring((filePath.lastIndexOf(".") + 1),
                  filePath.length());
  
          if (AppConstant.FILE_EXTN
                  .contains(ext.toLowerCase(Locale.getDefault())))
              return true;
          else
              return false;
  
      }
  
      /*
       * getting screen width
       */
      public int getScreenWidth() {
          int columnWidth;
          WindowManager wm = (WindowManager) _context
                  .getSystemService(Context.WINDOW_SERVICE);
          Display display = wm.getDefaultDisplay();
  
          final Point point = new Point();
          try {
              display.getSize(point);
          } catch (NoSuchMethodError ignore) { // Older device
              point.x = display.getWidth();
              point.y = display.getHeight();
          }
          columnWidth = point.x;
          return columnWidth;
      }
  
  
      public static int getMaxTextureSize() {
          // Safe minimum default size
          final int IMAGE_MAX_BITMAP_DIMENSION = 2048;
  
          // Get EGL Display
          EGL10 egl = (EGL10) EGLContext.getEGL();
          EGLDisplay display = egl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
  
          // Initialise
          int[] version = new int[2];
          egl.eglInitialize(display, version);
  
          // Query total number of configurations
          int[] totalConfigurations = new int[1];
          egl.eglGetConfigs(display, null, 0, totalConfigurations);
  
          // Query actual list configurations
          EGLConfig[] configurationsList = new EGLConfig[totalConfigurations[0]];
          egl.eglGetConfigs(display, configurationsList, totalConfigurations[0], totalConfigurations);
  
          int[] textureSize = new int[1];
          int maximumTextureSize = 0;
  
          // Iterate through all the configurations to located the maximum texture size
          for (int i = 0; i < totalConfigurations[0]; i++) {
              // Only need to check for width since opengl textures are always squared
              egl.eglGetConfigAttrib(display, configurationsList[i], EGL10.EGL_MAX_PBUFFER_WIDTH, textureSize);
  
              // Keep track of the maximum texture size
              if (maximumTextureSize < textureSize[0])
                  maximumTextureSize = textureSize[0];
          }
  
          // Release
          egl.eglTerminate(display);
  
          // Return largest texture size found, or default
          return Math.max(maximumTextureSize, IMAGE_MAX_BITMAP_DIMENSION);
      }
  
      public static boolean isMatch(String s, String pattern) {
          try {
              Pattern patt = Pattern.compile(pattern);
              Matcher matcher = patt.matcher(s);
              return matcher.matches();
          } catch (RuntimeException e) {
              return false;
          }
      }
  
      public static Bitmap decodeSampledBitmapFromUri(String path, int reqWidth, int reqHeight) {
  
          Bitmap bm = null;
          // First decode with inJustDecodeBounds=true to check dimensions
          final BitmapFactory.Options options = new BitmapFactory.Options();
          options.inJustDecodeBounds = true;
          BitmapFactory.decodeFile(path, options);
  
          // Calculate inSampleSize
          options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
  
          // Decode bitmap with inSampleSize set
          options.inJustDecodeBounds = false;
          bm = BitmapFactory.decodeFile(path, options);
  
          return bm;
      }
  
      public static int calculateInSampleSize(
              BitmapFactory.Options options, int reqWidth, int reqHeight) {
  
          // Raw height and width of image
          final int height = options.outHeight;
          final int width = options.outWidth;
          int inSampleSize = 1;
  
          if (height > reqHeight || width > reqWidth) {
              if (width > height) {
                  inSampleSize = Math.round((float)height / (float)reqHeight);
              } else {
                  inSampleSize = Math.round((float)width / (float)reqWidth);
              }
          }
  
          return inSampleSize;
      }
  
      public static void addImageToGallery(final String filePath, final Context context) {
  
          ContentValues values = new ContentValues();
  
          values.put(MediaStore.Images.Media.DATE_TAKEN, System.currentTimeMillis());
          values.put(MediaStore.Images.Media.MIME_TYPE, "image/jpeg");
          values.put(MediaStore.MediaColumns.DATA, filePath);
  
          context.getContentResolver().insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values);
      }
  
      public static void removeImageFromGallery(String filePath, Context context) {
          context.getContentResolver().delete(MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
                  MediaStore.Images.Media.DATA
                          + "='"
                          + filePath
                          + "'", null);
      }
  
      public static boolean isPackageInstalled(Context context , String packagename) {
          PackageManager pm = context.getPackageManager();
          boolean app_installed = false;
          try
          {
              PackageInfo info = pm.getPackageInfo(packagename, PackageManager.GET_ACTIVITIES);
              String label = (String) info.applicationInfo.loadLabel(pm);
              app_installed = (label != null);
          }
          catch (PackageManager.NameNotFoundException e)
          {
              app_installed = false;
          }
          return app_installed;
      }
  }
  