fragment화 권한을 확인하는 방법

fragment화 권한을 확인하는 방법

fragment 내부의 허가를 확인하고 싶습니다.

내 코드:

        // Here, thisActivity is the current activity
        if (ContextCompat.checkSelfPermission(getActivity(),
                Manifest.permission.ACCESS_FINE_LOCATION)
                != PackageManager.PERMISSION_GRANTED) {


            // Should we show an explanation?
            if (ActivityCompat.shouldShowRequestPermissionRationale(getActivity(),
                    android.Manifest.permission.ACCESS_FINE_LOCATION)) {

                // Show an explanation 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.

            } else {

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

                ActivityCompat.requestPermissions(getActivity(),
                        new String[]{android.Manifest.permission.ACCESS_FINE_LOCATION},
                        1);



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

그렇지만onRequestPermissionsResult허용 또는 거부 후에 호출되지 않습니다.

@Override
public void onRequestPermissionsResult(int requestCode,
                                       String permissions[], int[] grantResults) {
    switch (requestCode) {
        case 1: {
            Log.e("test","0");
            // If request is cancelled, the result arrays are empty.
            if (grantResults.length > 0
                    && grantResults[0] == PackageManager.PERMISSION_GRANTED) {

                // permission was granted, yay! Do the
                // contacts-related task you need to do.
                //yes

                Log.e("test","1");

                Intent intent = new Intent(getActivity(), MapsActivity.class);
                intent.putExtra("latitude", 35.694828);
                intent.putExtra("longitude", 51.378129);
                startActivity(intent);

            } else {
                utilityFunctions.showSweetAlertWarning(getActivity(),r.getString(R.string.str_warning_title_empty),
                        r.getString(R.string.str_you_must_allow_this_permission_toast),
                        r.getString(R.string.str_warning_btn_login));

                Log.e("test","2");
            }
            return;
        }

        // other 'case' lines to check for other
        // permissions this app might request
    }
}

이게 내가 한 방법이야, 나한테는 효과가 있어.감사합니다!

액티비티의 경우:

ActivityCompat.requestPermissions(this, permissionsList, REQUEST_CODE);

fragment의 경우:

requestPermissions(permissionsList, REQUEST_CODE);

프래그먼트에는 및 메서드가 있습니다.사용하십시오.

그렇지만checkSelfPermission()에서 왔다ActivityCompat(필요 없음Activity,오직.Context).

if (ActivityCompat.checkSelfPermission(getContext(), Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
    requestPermissions( //Method of Fragment
        new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, 
        REQUEST_PERMISSIONS_CODE_WRITE_STORAGE
    );
} else {
    downloadImage();
}

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    if (requestCode == REQUEST_PERMISSIONS_CODE_WRITE_STORAGE) {
        if (permissions[0].equals(Manifest.permission.WRITE_EXTERNAL_STORAGE)
                && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            proceedWithSdCard();
        }
    }
}

fragment내의 허가를 확인하기 위해서, 다음의 작업을 실시했습니다.

if (ActivityCompat.checkSelfPermission(getContext(),
            android.Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &&
            ActivityCompat.checkSelfPermission(getContext(),
                    android.Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
         requestPermissions(getActivity(),
                new String[]{android.Manifest.permission.ACCESS_COARSE_LOCATION,
                        android.Manifest.permission.ACCESS_FINE_LOCATION},
                REQUEST_LOCATION);
    } else {
        Log.e("DB", "PERMISSION GRANTED");
    }

갱신하다

부터Fragment.requestPermissions이제 더 이상 사용되지 않는다고 구글은 조언합니다.registerForActivityResult대신.

저는 다음과 같이 요청을 했습니다.

val permissionLauncher = registerForActivityResult(
    ActivityResultContracts.RequestPermission()
) { isGranted ->
    if (isGranted) {
        // Do if the permission is granted
    }
    else {
        // Do otherwise
    }
}

permissionLauncher.launch(Manifest.permission.ACCESS_FINE_LOCATION)

이 방법에 대한 자세한 내용은 이 링크를 참조하십시오.

fragment로부터의 권한 확인(2021년 방식)

그registerForActivityResult()fragment화된 메서드는 폐지되었습니다.권장 해제 메시지에서 다음을 사용할 것을 제안합니다.registerForActivityResult시행착오를 겪은 후 2021년 방법은 다음과 같습니다.

네 조각의 이름이AwesomeFragment그리고 (파편이 나오기 전에) 컨스트럭터에서onCreate정확한 방법)을 초기화합니다.ActivityResultLauncher<String[]> activityResultLauncher.

자바 버전

private ActivityResultLauncher<String[]> activityResultLauncher; 

public AwrsomeFragment() {
 activityResultLauncher = registerForActivityResult(new ActivityResultContracts.RequestMultiplePermissions(), new ActivityResultCallback<Map<String, Boolean>>() {
            @Override
            public void onActivityResult(Map<String, Boolean> result) {
                Log.e("activityResultLauncher", ""+result.toString());
                Boolean areAllGranted = true;
                for(Boolean b : result.values()) {
                    areAllGranted = areAllGranted && b;
                }

                if(areAllGranted) {
                    capturePhoto();
                }
            }
        });
}

그런 다음 버튼을 클릭하면launch방법:

    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        String[] appPerms;
        appPerms = new String[]{Manifest.permission.READ_EXTERNAL_STORAGE, Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.CAMERA};
        this.cameraClick.setOnClickListener(v -> {
            this.activityResultLauncher.launch(appPerms);
        });
    }

코틀린 버전

private var activityResultLauncher: ActivityResultLauncher<Array<String>>
init{
this.activityResultLauncher = registerForActivityResult(
        ActivityResultContracts.RequestMultiplePermissions()) {result ->
        var allAreGranted = true
        for(b in result.values) {
            allAreGranted = allAreGranted && b
        }
        
        if(allAreGranted) {
          capturePhoto()            
        }
    }
}

// --- ---
 override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
// ... ... init views / binding... ...
   someBtn.setOnClickListener{
        val appPerms = arrayOf(
            Manifest.permission.READ_EXTERNAL_STORAGE,
            Manifest.permission.WRITE_EXTERNAL_STORAGE,
            Manifest.permission.CAMERA
        )
        activityResultLauncher.launch(appPerms)
  }       
}

에서 권한을 처리하려면Fragment불러requestPermissions방법.덮어쓰면onRequestPermissionsResultfragment와 액티비티 양쪽의 메서드(그 fragment를 포함)를 호출합니다.super.onRequestPermissionsResult(...)에 콜을 전파하는 액티비티 메서드에서onRequestPermissionsResultfragment내의 메서드.

Kotlin을 사용하면requestPermissions(arrayOf(Manifest.permission.THE_PERMISSION_CODE_YOU_WANT), PERMISSION_REQUEST_CODE)fragment에 다음 오버라이드를 추가합니다.

override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out kotlin.String>, grantResults: IntArray): Unit {

}

onRequestPermissionsResultfragment가 아닌 액티비티로 호출됩니다.덮어쓰기 시도onRequestPermissionsResult대신 활동을 합니다.

fragment 자체를 호출하는 것이 아니라 fragment가 실장되어 있는 액티비티 내에서 onRequest Permissions Result 메서드를 호출하는 것이 효과가 있었습니다.내부 onCreateView 메서드 fragment:

    Button.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            int permissionCheck = ContextCompat.checkSelfPermission(getActivity(), Manifest.permission.READ_EXTERNAL_STORAGE);

            if (permissionCheck != PackageManager.PERMISSION_GRANTED) {
                ActivityCompat.requestPermissions(getActivity(), new String[]{Manifest.permission.READ_EXTERNAL_STORAGE}, MY_PERMISSIONS_REQUEST_READ_MEDIA);
            }else{
                //Do your work
                fetchMethod();
            }

        }
});

fragment를 구현하는 데 도움이 되는 액티비티에서 onCreate 메서드 이외:

    @Override
public void onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults) {
    switch (requestCode) {
        case MY_PERMISSIONS_REQUEST_READ_MEDIA:
            if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                fetchMethod();

            }else{
                Toast.makeText(getApplicationContext(), "Permission not granted!", Toast.LENGTH_SHORT).show();
            }
            break;

        default:
            break;
    }
}

설정에서 앱 권한을 닫으면 코드 또는 마시멜로보다 낮은 안드로이드 버전에서 권한을 열 수 없습니다.

이 매뉴얼은 https://developer.android.com/training/permissions/requesting.html 에서 확인하실 수 있습니다.이 예는 https://www.learn2crack.com/2015/10/android-marshmallow-permissions.html 입니다.

내가 발을 헛디뎌서checkSelfPermission()에 있어서Fragment어떤 접근법이 가장 좋을까 고민하고 있습니다.Context 고유null(Kotlin 고유)...!!아니면 다른 거라도?

iosched에서 찾은 코드를 기반으로 다른 것을 선택했어요.아래 샘플을 보고 다음 샘플에 대해 기억하십시오.Fragment 있습니다.Activity , . . . . . . . .Context무효가 됩니다.

private fun fineLocationPermissionApproved(): Boolean {

    val context = context ?: return false

    return PackageManager.PERMISSION_GRANTED == checkSelfPermission(
        context,
        Manifest.permission.ACCESS_FINE_LOCATION
    )
}

fragment내의 허가를 확인하기 위해서, 다음과 같이 했습니다.

fragment의 onCreateView에 다음 항목을 추가하기 전에

private final int STORAGE_PERMISSION_CODE = 1;

private Activity mActivity;
 
 @Override
    public void onAttach(@NotNull Context context) {
        super.onAttach(context);
        mActivity = (Activity) context;
    }

권한을 확인합니다.

if ((ContextCompat.checkSelfPermission(mActivity, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED))
            {
                if (ActivityCompat.shouldShowRequestPermissionRationale(mActivity, Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
                    new AlertDialog.Builder(mActivity)
                            .setTitle("Permission needed")
                            .setMessage("Allow "+getResources().getString(R.string.app_name)+" to access your storage?")
                            .setPositiveButton("ok", (dialog, which) -> ActivityCompat.requestPermissions(mActivity,
                                    new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, STORAGE_PERMISSION_CODE)
                            )
                            .setNegativeButton("cancel", (dialog, which) -> {
                                dialog.dismiss();
                                Toast.makeText(mActivity, "Please allow this permission!", Toast.LENGTH_SHORT).show();
                            })
                            .create().show();
                } else {
                    ActivityCompat.requestPermissions(mActivity,
                            new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, STORAGE_PERMISSION_CODE);
                }
            }

사용자가 권한을 영원히 거부한 경우 다음 코드를 MainActivity에 배치하여 앱 설정에서 권한을 활성화합니다.

@Override
            public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) 
            {
                super.onRequestPermissionsResult(requestCode, permissions, grantResults);
                if (requestCode == STORAGE_PERMISSION_CODE) {
        
                    if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                        Toast.makeText(this, "Permission GRANTED", Toast.LENGTH_SHORT).show();
                    } else {
        
                        //Now further we check if used denied permanently or not
                        if (ActivityCompat.shouldShowRequestPermissionRationale(MainActivity.this,
                                Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
                            // 1. The user has temporarily denied permission.
                            Toast.makeText(MainActivity.this, "Permission DENIED", Toast.LENGTH_SHORT).show();
        
                        } else {
                            // 2. Permission has been denied.
                            // From here, you can access the setting's page.
        
                            new AlertDialog.Builder(MainActivity.this)
                                    .setTitle("Permission Required")
                                    .setMessage("This permission was already declined by you. Please open settings, go to \"Permissions\", and allow the permission.")
                                    .setPositiveButton("Settings", (dialog, which) -> {
                                        final Intent i = new Intent();
                                        i.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
                                        i.addCategory(Intent.CATEGORY_DEFAULT);
                                        i.setData(Uri.parse("package:" + MainActivity.this.getPackageName()));
                                        i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                                        i.addFlags(Intent.FLAG_ACTIVITY_NO_HISTORY);
                                        i.addFlags(Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
                                        MainActivity.this.startActivity(i);
                                    })
                                    .setNegativeButton("cancel", (dialog, which) -> {
                                        dialog.dismiss();
                                        Toast.makeText(MainActivity.this, "Please allow this permission!", Toast.LENGTH_SHORT).show();
                                    })
                                    .create().show();
                        }
        
                    }
                }
            }

코틀린에게 관심 있는 사람이 있으면 허락을 구하세요.

    private fun directCall() {
    val numberText = phoneNo
    val intent = Intent(Intent.ACTION_CALL)
    intent.data = Uri.parse("tel:$numberText")
    if (ActivityCompat.checkSelfPermission(requireContext(),Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED)
    {
        if(ActivityCompat.shouldShowRequestPermissionRationale(requireActivity(), Manifest.permission.CALL_PHONE)){
                Toast.makeText(requireContext(), "Permission denied.", Toast.LENGTH_LONG).show()
                return //<-- Check user input history if user already denied then second time not request and not ask.
        }
        else{
            requestPermissions(arrayOf(Manifest.permission.CALL_PHONE),1)
            return //<--return will call onRequestPermissionsResult and wait for user input.
        }
    }
    startActivity(intent)
}

override fun onRequestPermissionsResult(requestCode: Int,permissions: Array<out String>,grantResults: IntArray) {
    if (requestCode == requestPhoneCall && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
        directCall()
    }else{
        Toast.makeText(requireContext(), "Permission denied", Toast.LENGTH_LONG).show()
        return
    }
}

언급URL : https://stackoverflow.com/questions/40760625/how-to-check-permission-in-fragment