@Override
  public void onConnected(Bundle bundle) {
    if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
            != PackageManager.PERMISSION_GRANTED
        && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION)
            != PackageManager.PERMISSION_GRANTED) {
      // TODO: Consider calling
      //    ActivityCompat#requestPermissions
      // here to request the missing permissions, and then overriding
      //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
      //                                          int[] grantResults)
      // to handle the case where the user grants the permission. See the documentation
      // for ActivityCompat#requestPermissions for more details.
      return;
    }

    Location location = LocationServices.FusedLocationApi.getLastLocation(mGoogleApiClient);

    if (location == null) {
      LocationServices.FusedLocationApi.requestLocationUpdates(
          mGoogleApiClient, mLocationRequest, this);
    } else {
      handleNewLocation(location);
    }

    Log.i(TAG, "Location services connected.");
  }
Exemple #2
0
 private void checkForStoragePermission(int position, SimpleItemViewHolder holder) {
   if (ContextCompat.checkSelfPermission(context, Manifest.permission.WRITE_EXTERNAL_STORAGE)
       == PackageManager.PERMISSION_GRANTED) {
     getWallpaper(position);
   } else {
     if (ActivityCompat.shouldShowRequestPermissionRationale(
         (Activity) context, Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
       Snackbar.make(
               holder.mainView, R.string.permission_storage_rationale, Snackbar.LENGTH_INDEFINITE)
           .setAction(
               R.string.ok,
               new View.OnClickListener() {
                 @Override
                 public void onClick(View view) {
                   ActivityCompat.requestPermissions(
                       (Activity) context,
                       new String[] {Manifest.permission.WRITE_EXTERNAL_STORAGE},
                       REQUEST_STORAGE);
                 }
               })
           .show();
     } else {
       reqPos = position;
       ActivityCompat.requestPermissions(
           ((Activity) context),
           new String[] {Manifest.permission.WRITE_EXTERNAL_STORAGE},
           REQUEST_STORAGE);
     }
   }
 }
  // If you want location on changing place also than use below method
  // otherwise remove all below methods and don't implement location listener
  @Override
  public void onLocationChanged(Location arg0) {
    if (!working) return;

    Log.d("TEST", "LocationChanged");
    if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
            != PackageManager.PERMISSION_GRANTED
        && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION)
            != PackageManager.PERMISSION_GRANTED) {
      return;
    }
    l = lm.getLastKnownLocation(provider);
    double diff_x =
        Math.abs(l.getLongitude() - goList.get(active).getLongitude())
            * degToM
            * Math.abs(Math.cos(l.getLatitude()));
    double diff_y = Math.abs(l.getLatitude() - goList.get(active).getLatitude()) * degToM;
    double dist = Math.sqrt(Math.pow(diff_x, 2) + Math.pow(diff_y, 2));

    x.setText("" + diff_x);
    y.setText("" + diff_y);
    if (diff_x > TOLLERANCE || diff_y > TOLLERANCE) {
      currentDistance.setText(
          getString(R.string.activityGame_currentDistance_label, getDistance(dist)));
    } else {
      goToNextPoint();
    }
    Log.d("ERROR", "Zginąłeś");
  }
  /**
   * Handles the requesting of the camera permission. This includes showing a "Snackbar" message of
   * why the permission is needed then sending the request.
   */
  private void requestCameraPermission() {
    Log.w(TAG, "Camera permission not granted, requesting...");

    final String[] permissions = new String[] {Manifest.permission.CAMERA};

    if (!ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.CAMERA)) {
      Log.d(TAG, "We do not need to show permission rationale");
      ActivityCompat.requestPermissions(this, permissions, RC_HANDLE_CAMERA_PERM);
      return;
    }

    final Activity thisActivity = this;

    Log.i(TAG, "Showing Request Permissions Rationale");
    View.OnClickListener listener =
        new View.OnClickListener() {
          @Override
          public void onClick(View view) {
            ActivityCompat.requestPermissions(thisActivity, permissions, RC_HANDLE_CAMERA_PERM);
          }
        };

    Snackbar.make(mGraphicOverlay, R.string.permission_camera_rationale, Snackbar.LENGTH_INDEFINITE)
        .setAction(android.R.string.ok, listener)
        .show();
  }
Exemple #5
0
 /**
  * Check if we have the GET_ACCOUNTS permission and request it if we do not.
  *
  * @return true if we have the permission, false if we do not.
  */
 private boolean checkAccountsPermission() {
   final String perm = Manifest.permission.GET_ACCOUNTS;
   int permissionCheck = ContextCompat.checkSelfPermission(getContext(), perm);
   if (permissionCheck == PackageManager.PERMISSION_GRANTED) {
     // We have the permission
     return true;
   } else if (ActivityCompat.shouldShowRequestPermissionRationale(getActivity(), perm)) {
     // Need to show permission rationale, display a snackbar and then request
     // the permission again when the snackbar is dismissed.
     Snackbar.make(
             recViewLogin.findViewById(R.id.login_layout),
             R.string.contacts_permission_rationale,
             Snackbar.LENGTH_INDEFINITE)
         .setAction(
             android.R.string.ok,
             new View.OnClickListener() {
               @Override
               public void onClick(View v) {
                 // Request the permission again.
                 ActivityCompat.requestPermissions(
                     getActivity(), new String[] {perm}, RC_PERM_GET_ACCOUNTS);
               }
             })
         .show();
     return false;
   } else {
     // No explanation needed, we can request the permission.
     ActivityCompat.requestPermissions(getActivity(), new String[] {perm}, RC_PERM_GET_ACCOUNTS);
     return false;
   }
 }
  void startAvatarTaker() {
    int permissionCheck =
        ContextCompat.checkSelfPermission(getActivity(), Manifest.permission.CAMERA);

    if (permissionCheck == PackageManager.PERMISSION_DENIED) {
      // Should we show an explanation?
      if (ActivityCompat.shouldShowRequestPermissionRationale(
          getActivity(), Manifest.permission.CAMERA)) {

        // Show an expanation to the user *asynchronously* -- don't block
        // this thread waiting for the user's response! After the user
        // sees the explanation, try again to request the permission.
        Snackbar.make(mView, R.string.grant_perms, Snackbar.LENGTH_LONG).show();
      } else {

        // No explanation needed, we can request the permission.

        ActivityCompat.requestPermissions(
            getActivity(),
            new String[] {Manifest.permission.CAMERA},
            MY_PERMISSIONS_REQUEST_CAMERA);

        // MY_PERMISSIONS_REQUEST_READ_CONTACTS is an
        // app-defined int constant. The callback method gets the
        // result of the request.
      }
    } else {

      startActivityForResult(getPickImageChooserIntent(), 200);
    }
  }
Exemple #7
0
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    Log.d(TAG, "MainActivity  - onCreate");

    // Check that the Permission to read From External storage - if the checkselfPermission is null
    // than it means that the user has clicked on "Never Ask me again".
    if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE)
        != PackageManager.PERMISSION_GRANTED) {
      // Check if we should show the Permission RAtional behind the reason we are asking for the
      // Permissions
      if (ActivityCompat.shouldShowRequestPermissionRationale(
          this, Manifest.permission.READ_EXTERNAL_STORAGE)) {
        // Show a Fragment that explains why I need this permission
      } else {
        ActivityCompat.requestPermissions(
            this,
            new String[] {Manifest.permission.READ_EXTERNAL_STORAGE},
            READ_EXTERNAL_STORAGE_REQUEST_CODE);
      }
    }

    // Create the List from Storage
    getExternalRootFolderList();

    // Conect the Fragment to the Activity
    listFragment = new FolderViewFragment();
    getSupportFragmentManager()
        .beginTransaction()
        .add(R.id.fragment_container, listFragment)
        .commit();
  }
  private void getPermission() {
    if (ContextCompat.checkSelfPermission(this, Manifest.permission.GET_ACCOUNTS)
        != PackageManager.PERMISSION_GRANTED) {

      if (ActivityCompat.shouldShowRequestPermissionRationale(
          this, Manifest.permission.GET_ACCOUNTS)) {

        AlertDialog.Builder builder = new AlertDialog.Builder(this);
        builder.setTitle("Permission Request");
        builder.setMessage(
            "To bring you timely alerts we would require few permissions such as account details. Please grant the permissions to continue using these features");
        builder.setPositiveButton(
            "OK",
            new DialogInterface.OnClickListener() {
              @Override
              public void onClick(DialogInterface dialogInterface, int i) {
                dialogInterface.dismiss();
                ActivityCompat.requestPermissions(
                    MainActivity.this,
                    new String[] {Manifest.permission.GET_ACCOUNTS},
                    MY_PERMISSIONS_REQUEST_GET_ACCOUNTS);
              }
            });
        builder.create().show();

      } else {
        ActivityCompat.requestPermissions(
            this,
            new String[] {Manifest.permission.GET_ACCOUNTS},
            MY_PERMISSIONS_REQUEST_GET_ACCOUNTS);
      }
    } else {
      setupUser();
    }
  }
Exemple #9
0
  @TargetApi(Build.VERSION_CODES.M)
  @Override
  public void onMapReady(GoogleMap map) {
    // Add a marker in Sydney, Australia, and move the camera.
    try {
      map.setMyLocationEnabled(true);
    } catch (Exception e) {
      statusCheck();
    }

    map.getUiSettings().setCompassEnabled(true);
    LocationManager locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
    Criteria criteria = new Criteria();
    if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
            != PackageManager.PERMISSION_GRANTED
        && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION)
            != PackageManager.PERMISSION_GRANTED) {
      // TODO: Consider calling
      //    ActivityCompat#requestPermissions
      // here to request the missing permissions, and then overriding
      //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
      //                                          int[] grantResults)
      // to handle the case where the user grants the permission. See the documentation
      // for ActivityCompat#requestPermissions for more details.
      return;
    }
    Location location =
        locationManager.getLastKnownLocation(locationManager.getBestProvider(criteria, false));
    /*LocationManager locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
    Criteria criteria = new Criteria();
    Location location = locationManager.getLastKnownLocation(locationManager.getBestProvider(criteria, false));
    if (location != null) {
        map.animateCamera(CameraUpdateFactory.newLatLngZoom(
                new LatLng(location.getLatitude(), location.getLongitude()), 13));

        CameraPosition cameraPosition = new CameraPosition.Builder()
                .target(new LatLng(location.getLatitude(), location.getLongitude()))      // Sets the center of the map to location user
                .zoom(16)                   // Sets the zoom
                .tilt(10)                   // Sets the tilt of the camera to 30 degrees
                .build();                   // Creates a CameraPosition from the builder
        map.animateCamera(CameraUpdateFactory.newCameraPosition(cameraPosition));*/
    ctx = this.getApplicationContext();
    t = new TestAdapter(ctx);
    Bundle extras = getIntent().getExtras();
    String tag = null;
    System.out.println("hi this is tag extra");
    if (extras != null) {
      tag = extras.getString("tag2");
      // The key argument here must match that used in the other activity
      System.out.println(tag);
      try {

        LoadingGoogleMap(t.getCordinates(tag), map);
        System.out.println("cordinates are done");
      } catch (NullPointerException e) {
        e.printStackTrace();
      }
    }
  }
Exemple #10
0
 private boolean checkLocationAccessPermission() {
   return ActivityCompat.checkSelfPermission(
               getActivity(), android.Manifest.permission.ACCESS_FINE_LOCATION)
           == PackageManager.PERMISSION_GRANTED
       || ActivityCompat.checkSelfPermission(
               getActivity(), android.Manifest.permission.ACCESS_COARSE_LOCATION)
           == PackageManager.PERMISSION_GRANTED;
 }
Exemple #11
0
 @SuppressWarnings("SameParameterValue")
 private void perm(String permission, int permission_request) {
   if (ContextCompat.checkSelfPermission(this, permission) != PackageManager.PERMISSION_GRANTED) {
     if (!ActivityCompat.shouldShowRequestPermissionRationale(this, permission)) {
       ActivityCompat.requestPermissions(this, new String[] {permission}, permission_request);
     }
   }
 }
 public void requestInternetPermission() {
   if (ActivityCompat.shouldShowRequestPermissionRationale(
       activity, Manifest.permission.INTERNET)) {
     permissionCallback.onPermissionExplanationRequired(true, Manifest.permission.INTERNET);
   } else {
     ActivityCompat.requestPermissions(
         activity, new String[] {Manifest.permission.INTERNET}, INTERNET_PERMISSION);
   }
 }
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_round_tab);
    ButterKnife.bind(this);

    mNavigationBar
        .setDisplayBackButton(true)
        .setBackButtonImageResource(R.drawable.ic_chevron_left_white_24dp)
        .setBackButtonText("Back")
        .setOnBackButtonClickListener(
            new View.OnClickListener() {
              @Override
              public void onClick(View v) {
                onBackPressed();
              }
            })
        .addItem(0, "Settings", ActivityCompat.getDrawable(this, R.drawable.ic_settings_white_24dp))
        .addItem(1, "More", ActivityCompat.getDrawable(this, R.drawable.ic_more_vert_white_24dp))
        .setOnMenuItemClickListener(
            new NavigationBar.OnMenuItemClickListener() {
              @Override
              public void onMenuItemClick(int id) {
                Toast.makeText(getApplicationContext(), "" + id, Toast.LENGTH_SHORT).show();
              }
            })
        .setTabs(new String[] {"music", "video", "games"})
        .setOnTabCheckedListener(
            new NavigationBar.OnTabCheckedListener() {
              @Override
              public void onTabChecked(int position) {
                Toast.makeText(
                        getApplicationContext(),
                        "Tab " + position + " is checked",
                        Toast.LENGTH_SHORT)
                    .show();
              }
            })
        .bindViewPager(mViewPager);

    mFragmentList.add(TabFragment.newInstance(TAB_NANES[0]));
    mFragmentList.add(TabFragment.newInstance(TAB_NANES[1]));
    mFragmentList.add(TabFragment.newInstance(TAB_NANES[2]));

    mViewPagerAdapter = new ViewPagerAdapter(getSupportFragmentManager());
    mViewPager.setAdapter(mViewPagerAdapter);

    mSearchView.setImeOption(EditorInfo.IME_ACTION_SEARCH);
    mSearchView.setOnEditorActionListener(mOnEditorActionListener);

    mSearchView.setOnFocusChangeListener(mOnFocusChangeListener);
    mSearchView.setButtonTextColor(BG_COLOR);
    mSearchView.setHint("Search");
    mSearchView.setHintTextColor(0xFF8E8E93);
    mSearchView.setButtonText("Cancel");
    mSearchView.setStyle(SearchView.Style.ROUND);
  }
Exemple #14
0
 private boolean doNeedPermission() {
   if (ActivityCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE)
           != PackageManager.PERMISSION_GRANTED
       || ActivityCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
           != PackageManager.PERMISSION_GRANTED) {
     requestPermission();
     return true;
   }
   return false;
 }
Exemple #15
0
 public boolean checkGplusPermission() {
   // Verify that all required contact permissions have been granted.
   if (ActivityCompat.checkSelfPermission(getActivity(), Manifest.permission.GET_ACCOUNTS)
           != PackageManager.PERMISSION_GRANTED
       || ActivityCompat.checkSelfPermission(getActivity(), Manifest.permission.INTERNET)
           != PackageManager.PERMISSION_GRANTED) {
     return false;
   }
   return true;
 }
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    ButterKnife.bind(this);

    mProgressBar.setVisibility(View.INVISIBLE);

    Log.d(TAG, "ProgressBar set to invisible");

    locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
    Log.d(TAG, "Location Manager setup.");
    if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
            != PackageManager.PERMISSION_GRANTED
        && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION)
            != PackageManager.PERMISSION_GRANTED) {
      // TODO: Consider calling
      //    ActivityCompat#requestPermissions
      // here to request the missing permissions, and then overriding
      //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
      //                                          int[] grantResults)
      // to handle the case where the user grants the permission. See the documentation
      // for ActivityCompat#requestPermissions for more details.

      Log.d(TAG, "Inside main IF block");
      double latitude = 12.903238;
      double longitude = 77.647602;
      Log.d(TAG, "Lat =" + latitude + " Long= " + longitude);

      Toast.makeText(MainActivity.this, R.string.loc_perm_unavailable_msg, Toast.LENGTH_LONG)
          .show();

      // return;
    } else {
      Log.d(TAG, "Inside ELSE block");
      locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, this);
      Log.d(TAG, "real-time location retrieved");
    }

    // Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
    // setSupportActionBar(toolbar);

    mRefreshImage.setOnClickListener(
        new View.OnClickListener() {
          @Override
          public void onClick(View v) {
            getForecast(latitude, longitude);
          }
        });

    getForecast(latitude, longitude);

    Log.d(TAG, "This is running on Main thread");
  }
 /**
  * Requests the fine location permission. If a rationale with an additional explanation should be
  * shown to the user, displays a dialog that triggers the request.
  */
 public static void requestPermission(
     AppCompatActivity activity, int requestId, String permission, boolean finishActivity) {
   if (ActivityCompat.shouldShowRequestPermissionRationale(activity, permission)) {
     // Display a dialog with rationale.
     RationaleDialog.newInstance(requestId, finishActivity)
         .show(activity.getSupportFragmentManager(), "dialog");
   } else {
     // Location permission has not been granted yet, request it.
     ActivityCompat.requestPermissions(activity, new String[] {permission}, requestId);
   }
 }
 public void requestExternalStoragePermission() {
   if (ActivityCompat.shouldShowRequestPermissionRationale(
       activity, Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
     permissionCallback.onPermissionExplanationRequired(
         true, Manifest.permission.WRITE_EXTERNAL_STORAGE);
   } else {
     ActivityCompat.requestPermissions(
         activity,
         new String[] {Manifest.permission.WRITE_EXTERNAL_STORAGE},
         EXTERNAL_STORAGE_PERMISSION);
   }
 }
 private void requestPermissionForCameraAndMicrophone() {
   if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.CAMERA)
       || ActivityCompat.shouldShowRequestPermissionRationale(
           this, Manifest.permission.RECORD_AUDIO)) {
     Toast.makeText(this, R.string.permissions_needed, Toast.LENGTH_LONG).show();
   } else {
     ActivityCompat.requestPermissions(
         this,
         new String[] {Manifest.permission.CAMERA, Manifest.permission.RECORD_AUDIO},
         CAMERA_MIC_PERMISSION_REQUEST_CODE);
   }
 }
 public void browse(View view) {
   // browse = R.id.browse;
   if (ActivityCompat.checkSelfPermission(
           Create_Assignment.this, Manifest.permission.READ_EXTERNAL_STORAGE)
       != PackageManager.PERMISSION_GRANTED) {
     ActivityCompat.requestPermissions(
         Create_Assignment.this,
         new String[] {Manifest.permission.READ_EXTERNAL_STORAGE},
         STORAGE_PERMISSION_RC);
     return;
   }
   new FileChooserDialog.Builder(this).show();
 }
Exemple #21
0
  public static boolean checkPermission(Activity activity, String permission, int code) {
    if (ContextCompat.checkSelfPermission(activity, permission)
        != PackageManager.PERMISSION_GRANTED) {

      if (ActivityCompat.shouldShowRequestPermissionRationale(activity, permission)) {
        ActivityCompat.requestPermissions(activity, new String[] {permission}, code);
      } else {
        ActivityCompat.requestPermissions(activity, new String[] {permission}, code);
      }
      return false;
    }
    return true;
  }
 public void requestExternalStoragePermission(
     AppCompatActivity appCompatActivity, PermissionCallback callback, boolean requestFromDialog) {
   if (ActivityCompat.shouldShowRequestPermissionRationale(
           appCompatActivity, Manifest.permission.WRITE_EXTERNAL_STORAGE)
       && !requestFromDialog) {
     callback.onPermissionExplanationRequired(true, Manifest.permission.WRITE_EXTERNAL_STORAGE);
   } else {
     ActivityCompat.requestPermissions(
         appCompatActivity,
         new String[] {Manifest.permission.WRITE_EXTERNAL_STORAGE},
         EXTERNAL_STORAGE_PERMISSION);
   }
 }
Exemple #23
0
  private void requestGplusPermission() {
    final String[] PERMISSIONS = {Manifest.permission.GET_ACCOUNTS, Manifest.permission.INTERNET};
    if (ActivityCompat.shouldShowRequestPermissionRationale(
            getActivity(), Manifest.permission.GET_ACCOUNTS)
        || ActivityCompat.shouldShowRequestPermissionRationale(
            getActivity(), Manifest.permission.INTERNET)) {
      // Provide an additional rationale to the user if the permission was not granted
      // and the user would benefit from additional context for the use of the permission.
      // For example, if the request has been denied previously.

      String fab_skin = (BaseActivity.accentSkin);
      final MaterialDialog materialDialog =
          Futils.showBasicDialog(
              getActivity(),
              fab_skin,
              theme,
              new String[] {
                getResources().getString(R.string.grantgplus),
                getResources().getString(R.string.grantper),
                getResources().getString(R.string.grant),
                getResources().getString(R.string.cancel),
                null
              });
      materialDialog
          .getActionButton(DialogAction.POSITIVE)
          .setOnClickListener(
              new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                  ActivityCompat.requestPermissions(getActivity(), PERMISSIONS, 66);
                  materialDialog.dismiss();
                }
              });
      materialDialog
          .getActionButton(DialogAction.NEGATIVE)
          .setOnClickListener(
              new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                  getActivity().finish();
                }
              });
      materialDialog.setCancelable(false);
      materialDialog.show();

    } else {
      // Contact permissions have not been granted yet. Request them directly.
      ActivityCompat.requestPermissions(getActivity(), PERMISSIONS, 66);
    }
  }
 public void onConnected(Bundle connectionHint) {
   if (ActivityCompat.checkSelfPermission(
               this.getActivity(), Manifest.permission.ACCESS_FINE_LOCATION)
           != PackageManager.PERMISSION_GRANTED
       && ActivityCompat.checkSelfPermission(
               this.getActivity(), Manifest.permission.ACCESS_COARSE_LOCATION)
           != PackageManager.PERMISSION_GRANTED) {
     return;
   }
   mLastLocation = LocationServices.FusedLocationApi.getLastLocation(mGoogleApiClient);
   if (mLastLocation != null) {
     latitude = mLastLocation.getLatitude();
     longitude = mLastLocation.getLongitude();
   }
 }
 private void requestLocationPermission() {
   if (checkSelfPermission(Manifest.permission.ACCESS_COARSE_LOCATION)
       != PackageManager.PERMISSION_GRANTED) {
     if (!ActivityCompat.shouldShowRequestPermissionRationale(
         this, Manifest.permission.ACCESS_COARSE_LOCATION)) {
       // User Denied and selected "Don't ask again" --> Show info that he needs to go to settings
       showSettingsDialog();
     } else {
       ActivityCompat.requestPermissions(
           this, MainActivity.PERMISSIONS_LOCATION, MainActivity.REQUEST_LOCATION);
     }
   } else {
     Snackbar.make(mLayout, "You already have this permission, FOOL!", Snackbar.LENGTH_SHORT);
   }
 }
  private void requestNetworkStatePermission() {
    // Permission has not been granted and must be requested.

    /**
     * if (ActivityCompat.shouldShowRequestPermissionRationale(this,
     * Manifest.permission.ACCESS_NETWORK_STATE)) { // Provide an additional rationale to the user
     * if the permission was not granted // and the user would benefit from additional context for
     * the use of the permission. // Display a SnackBar with a button to request the missing
     * permission. Snackbar.make(mLayout, "Permission Access Network State is Required.",
     * Snackbar.LENGTH_INDEFINITE).setAction("OK", new View.OnClickListener() { @Override public
     * void onClick(View view) { // Request the permission
     * ActivityCompat.requestPermissions(MainActivity.this, new
     * String[]{Manifest.permission.ACCESS_NETWORK_STATE}, PERMISSION_REQUEST_NETWORK_STATE); }
     * }).show();
     *
     * <p>} else { Snackbar.make(mLayout, "Permission Access Network State is not available.
     * Requesting permission.", Snackbar.LENGTH_SHORT).show(); // Request the permission. The result
     * will be received in onRequestPermissionResult(). ActivityCompat.requestPermissions(this, new
     * String[]{Manifest.permission.ACCESS_NETWORK_STATE}, PERMISSION_REQUEST_NETWORK_STATE); }
     */
    if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.INTERNET)) {
      // Provide an additional rationale to the user if the permission was not granted
      // and the user would benefit from additional context for the use of the permission.
      // Display a SnackBar with a button to request the missing permission.
      Snackbar.make(mLayout, "Permission Internet is Required.", Snackbar.LENGTH_INDEFINITE)
          .setAction(
              "OK",
              new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                  // Request the permission
                  ActivityCompat.requestPermissions(
                      MainActivity.this,
                      new String[] {Manifest.permission.INTERNET},
                      PERMISSION_REQUEST_INTERNET);
                }
              })
          .show();

    } else {
      Snackbar.make(
              mLayout, "Internet is not available. Requesting permission.", Snackbar.LENGTH_SHORT)
          .show();
      // Request the permission. The result will be received in onRequestPermissionResult().
      ActivityCompat.requestPermissions(
          this, new String[] {Manifest.permission.INTERNET}, PERMISSION_REQUEST_INTERNET);
    }
  }
  public boolean onSupportNavigateUp() {
    Intent upIntent = getSupportParentActivityIntent();

    if (upIntent != null) {
      if (supportShouldUpRecreateTask(upIntent)) {
        TaskStackBuilder b = TaskStackBuilder.create(this);
        onCreateSupportNavigateUpTaskStack(b);
        onPrepareSupportNavigateUpTaskStack(b);
        b.startActivities();

        try {
          ActivityCompat.finishAffinity(this);
        } catch (IllegalStateException e) {
          // This can only happen on 4.1+, when we don't have a parent or a result set.
          // In that case we should just finish().
          finish();
        }
      } else {
        // This activity is part of the application's task, so simply
        // navigate up to the hierarchical parent activity.
        supportNavigateUpTo(upIntent);
      }
      return true;
    }
    return false;
  }
 @Override
 public void startForResult(int requestCode) {
   if (fragmentSupport_ != null) {
     fragmentSupport_.startActivityForResult(intent, requestCode);
   } else {
     if (fragment_ != null) {
       if (VERSION.SDK_INT >= VERSION_CODES.JELLY_BEAN) {
         fragment_.startActivityForResult(intent, requestCode, lastOptions);
       } else {
         fragment_.startActivityForResult(intent, requestCode);
       }
     } else {
       if (context instanceof Activity) {
         Activity activity = ((Activity) context);
         ActivityCompat.startActivityForResult(activity, intent, requestCode, lastOptions);
       } else {
         if (VERSION.SDK_INT >= VERSION_CODES.JELLY_BEAN) {
           context.startActivity(intent, lastOptions);
         } else {
           context.startActivity(intent);
         }
       }
     }
   }
 }
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.location_activity);

    // Locate UI widgets
    mStartUpdatesButton = (Button) findViewById(R.id.start_updates_button);
    mStopUpdatesButton = (Button) findViewById(R.id.stop_updates_button);
    mLatitudeTextView = (TextView) findViewById(R.id.latitude_text);
    mLongitudeTextView = (TextView) findViewById(R.id.longitude_text);
    mLastUpdateTextView = (TextView) findViewById(R.id.last_update_text);

    // Set labels.
    mLatitudeLabel = getResources().getString(R.string.latitude_label);
    mLongitudeLabel = getResources().getString(R.string.longitude_label);
    mLastUpdateLabel = getResources().getString(R.string.last_update_time_label);

    mRequestingLocationUpdates = true;

    // Update values using data stored in the Bundle.
    updateValuesFromBundle(savedInstanceState);

    if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
        != PackageManager.PERMISSION_GRANTED) {

      ActivityCompat.requestPermissions(
          this,
          new String[] {Manifest.permission.ACCESS_FINE_LOCATION},
          MY_PERMISSIONS_REQUEST_FINE_LOCATION);
    }

    // Kick off the process of building a GoogleApiClient and requesting the LocationServices
    // API.
    buildGoogleApiClient();
  }
 private void launchPostTransitionAnimations() {
   if (LUtils.hasL()) {
     ActivityCompat.setEnterSharedElementCallback(
         this,
         new SharedElementCallback() {
           @Override
           public void onSharedElementEnd(
               List<String> sharedElementNames,
               List<View> sharedElements,
               List<View> sharedElementSnapshots) {
             binding.detailsContainer.postDelayed(
                 () -> {
                   binding.detailsContainer.startAnimation(
                       LUtils.loadAnimationWithLInterpolator(
                           ProjectDetailsActivity.this, R.anim.slide_from_top));
                   binding.scrollView.startAnimation(
                       LUtils.loadAnimationWithLInterpolator(
                           ProjectDetailsActivity.this, R.anim.slide_from_top_long));
                 },
                 0);
           }
         });
   }
   //        categoriesRv.post(() ->
   // categoriesRv.startAnimation(LUtils.loadAnimationWithLInterpolator(getApplicationContext(),
   // R.anim.slide_from_bottom)));
 }