android - card - मेमोरी कार्ड सेटिंग




एंड्रॉयड 6.0 मार्शमैलो। एसडी कार्ड को नहीं लिख सकते (4)

Android बदल गया कि Android 6.0 के साथ अनुमतियाँ कैसे काम करती हैं, यही आपकी त्रुटियों का कारण है। यदि उपयोगकर्ता द्वारा उपयोग करने की अनुमति दी गई थी, तो आपको वास्तव में अनुरोध करना होगा और जांचना होगा। इसलिए मैनिफ़ेस्ट फ़ाइल में अनुमतियाँ केवल 21 से कम की एपीआई के लिए काम करेंगी। इस लिंक की जाँच करें कि एपी 23 में अनुमतियों का अनुरोध कैसे किया जाता है http://android-developers.blogspot.nl/2015/09/google-play-services-81-and-android-60.html?m=1

कोड: -

If (ActivityCompat.checkSelfPermission(MainActivity.this, Manifest.permission.READ_EXTERNAL_STORAGE) !=
                PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions(MainActivity.this, new String[]{Manifest.permission.READ_EXTERNAL_STORAGE}, STORAGE_PERMISSION_RC);
            return;
        }`


` @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode == STORAGE_PERMISSION_RC) {
            if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                //permission granted  start reading
            } else {
                Toast.makeText(this, "No permission to read external storage.", Toast.LENGTH_SHORT).show();
            }
        }
    }
}

मेरे पास एक ऐप है जो तस्वीरों को स्टोर करने के लिए बाहरी स्टोरेज का उपयोग करता है। आवश्यकतानुसार, इसके प्रकट होने में, निम्नलिखित अनुमतियों का अनुरोध किया जाता है

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

और यह आवश्यक निर्देशिका को पुनः प्राप्त करने के लिए निम्नलिखित का उपयोग करता है

File sdDir = Environment
            .getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES);

SimpleDateFormat dateFormat = new SimpleDateFormat("MM-dd", Locale.US);
String date = dateFormat.format(new Date());
storageDir = new File(sdDir, getResources().getString(
            R.string.storagedir)
            + "-" + date);

// Create directory, error handling
if (!storageDir.exists() && !storageDir.mkdirs()) {
 ... fails here

ऐप एंड्रॉइड 5.1 से 2.3 पर ठीक काम करता है; यह Google Play पर एक साल से अधिक समय से है।

मेरे एक परीक्षण फोन (एंड्रॉइड वन) के 6 में अपग्रेड करने के बाद, अब अपेक्षित निर्देशिका, "/ sdcard / Pictures / myapp-yy-mm" बनाने की कोशिश करते समय एक त्रुटि वापस आ रही है।

एसडी कार्ड को "पोर्टेबल स्टोरेज" के रूप में कॉन्फ़िगर किया गया है। मैंने sd कार्ड फॉर्मेट किया है। मैंने इसे बदल दिया है। मैंने रिबूट किया है। कोई फायदा नहीं हुआ।

इसके अलावा, अंतर्निहित एंड्रॉइड स्क्रीनशॉट कार्यक्षमता (पावर + लोअर वॉल्यूम के माध्यम से) "सीमित भंडारण स्थान के कारण विफल हो रही है, या इसे ऐप या आपके संगठन द्वारा अनुमति नहीं है"।

कोई विचार?


पहले मैं आपको Android M और बाद के संस्करण में खतरनाक अनुमति सूची दूंगा

फिर आपको उदाहरण देता है कि एंड्रॉइड एम और बाद के संस्करण में अनुमति के लिए कैसे अनुरोध किया जाए।

मैं उपयोगकर्ता से WRITE_EXTERNAL_STORAGE अनुमति माँगता हूँ।

सबसे पहले अपने एंड्रॉइड मेनिफेस्ट फ़ाइल में अनुमति जोड़ें

चरण 1 डिक्लेयरकोड घोषित करें

 private static String TAG = "PermissionDemo";
 private static final int REQUEST_WRITE_STORAGE = 112; 

चरण 2 इस कोड को जोड़ें जब आप उपयोगकर्ता से अनुमति मांगते हैं

 //ask for the permission in android M
    int permission = ContextCompat.checkSelfPermission(this,
            Manifest.permission.WRITE_EXTERNAL_STORAGE);

    if (permission != PackageManager.PERMISSION_GRANTED) {
        Log.i(TAG, "Permission to record denied");

        if (ActivityCompat.shouldShowRequestPermissionRationale(this,
                Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
            AlertDialog.Builder builder = new AlertDialog.Builder(this);
            builder.setMessage("Permission to access the SD-CARD is required for this app to Download PDF.")
                    .setTitle("Permission required");

            builder.setPositiveButton("OK", new DialogInterface.OnClickListener() {

                public void onClick(DialogInterface dialog, int id) {
                    Log.i(TAG, "Clicked");
                    makeRequest();
                }
            });

            AlertDialog dialog = builder.create();
            dialog.show();

        } else {
            makeRequest();
        }
    }

    protected void makeRequest() {
        ActivityCompat.requestPermissions(this,
                new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
                REQUEST_WRITE_STORAGE);
    }

चरण 3 अनुरोध के लिए ओवरराइड विधि जोड़ें

 @Override
public void onRequestPermissionsResult(int requestCode,
                                       String permissions[], int[] grantResults) {
    switch (requestCode) {
        case REQUEST_WRITE_STORAGE: {

            if (grantResults.length == 0
                    || grantResults[0] !=
                    PackageManager.PERMISSION_GRANTED) {

                Log.i(TAG, "Permission has been denied by user");

            } else {

                Log.i(TAG, "Permission has been granted by user");

            }
            return;
        }
    }
}

नोट: मेनिफ़ेस्ट फ़ाइल में अनुमति जोड़ना न भूलें

बेस्ट एक्प्लिमेंट में मल्टीपल पेर्मिसन प्लस के साथ सभी स्केनरियो शामिल हैं

मैंने टिप्पणियों को जोड़ा ताकि आप आसानी से समझ सकें।

import android.Manifest;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.provider.Settings;
import android.support.annotation.NonNull;
import android.support.v4.app.ActivityCompat;
import android.support.v4.content.ContextCompat;
import android.support.v7.app.AlertDialog;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

import com.production.hometech.busycoder.R;

import java.util.ArrayList;

public class PermissionInActivity extends AppCompatActivity implements View.OnClickListener {

    private static final int REQUEST_PERMISSION_SETTING = 99;
    private Button bt_camera;
    private static final String[] PARAMS_TAKE_PHOTO = {
            Manifest.permission.CAMERA,
            Manifest.permission.WRITE_EXTERNAL_STORAGE
    };
    private static final int RESULT_PARAMS_TAKE_PHOTO = 11;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_permission_in);

        bt_camera = (Button) findViewById(R.id.bt_camera);

        bt_camera.setOnClickListener(this);

    }

    @Override
    public void onClick(View view) {

        switch (view.getId()) {

            case R.id.bt_camera:

                takePhoto();

                break;

        }
    }


    /**
     * shouldShowRequestPermissionRationale() = This will return true if the user had previously declined to grant you permission
     * NOTE :  that ActivityCompat also has a backwards-compatible implementation of
     * shouldShowRequestPermissionRationale(), so you can avoid your own API level
     * checks.
     * <p>
     * shouldShowRequestPermissionRationale() =  returns false if the user declined the permission and checked the checkbox to ask you to stop pestering the
     * user.
     * <p>
     * requestPermissions() = request for the permisssiion
     */
    private void takePhoto() {

        if (canTakePhoto()) {

            Toast.makeText(this, "You can take PHOTO", Toast.LENGTH_SHORT).show();

        } else if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.CAMERA) || ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)) {

            Toast.makeText(this, "You should give permission", Toast.LENGTH_SHORT).show();
            ActivityCompat.requestPermissions(this, netPermisssion(PARAMS_TAKE_PHOTO), RESULT_PARAMS_TAKE_PHOTO);

        } else {
            ActivityCompat.requestPermissions(this, netPermisssion(PARAMS_TAKE_PHOTO), RESULT_PARAMS_TAKE_PHOTO);
        }

    }

    //  This method return  permission denied String[] so we can request again
    private String[] netPermisssion(String[] wantedPermissions) {
        ArrayList<String> result = new ArrayList<>();

        for (String permission : wantedPermissions) {
            if (!hasPermission(permission)) {
                result.add(permission);
            }
        }

        return (result.toArray(new String[result.size()]));

    }

    private boolean canTakePhoto() {
        return (hasPermission(Manifest.permission.CAMERA) && hasPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE));
    }

    /**
     * checkSelfPermission() = you can check if you have been granted a runtime permission or not
     * ex = ContextCompat.checkSelfPermission(this,permissionString)== PackageManager.PERMISSION_GRANTED
     * <p>
     * ContextCompat offers a backwards-compatible implementation of checkSelfPermission(), ActivityCompat offers a backwards-compatible
     * implementation of requestPermissions() that you can use.
     *
     * @param permissionString
     * @return
     */
    private boolean hasPermission(String permissionString) {
        return (ContextCompat.checkSelfPermission(this, permissionString) == PackageManager.PERMISSION_GRANTED);
    }

    /**
     * requestPermissions() action goes to onRequestPermissionsResult() whether user can GARNT or DENIED those permisssions
     *
     * @param requestCode
     * @param permissions
     * @param grantResults
     */
    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);

        if (requestCode == RESULT_PARAMS_TAKE_PHOTO) {

            if (canTakePhoto()) {

                Toast.makeText(this, "You can take picture", Toast.LENGTH_SHORT).show();

            } else if (!(ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.CAMERA) || ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.WRITE_EXTERNAL_STORAGE))) {


                final AlertDialog.Builder settingDialog = new AlertDialog.Builder(PermissionInActivity.this);
                settingDialog.setTitle("Permissioin");
                settingDialog.setMessage("Now you need to enable permisssion from the setting because without permission this app won't run properly \n\n  goto -> setting -> appInfo");
                settingDialog.setCancelable(false);

                settingDialog.setPositiveButton("Setting", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialogInterface, int i) {

                        dialogInterface.cancel();

                        Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
                        Uri uri = Uri.fromParts("package", getPackageName(), null);
                        intent.setData(uri);
                        startActivityForResult(intent, REQUEST_PERMISSION_SETTING);
                        Toast.makeText(getBaseContext(), "Go to Permissions to Grant all permission ENABLE", Toast.LENGTH_LONG).show();

                    }
                });
                settingDialog.show();

                Toast.makeText(this, "You need to grant permission from setting", Toast.LENGTH_SHORT).show();

            }

        }

    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        if (requestCode == REQUEST_PERMISSION_SETTING) {

            if (canTakePhoto()) {

                Toast.makeText(this, "You can take PHOTO", Toast.LENGTH_SHORT).show();

            }

        }

    }


}

कॉन्फ़िगरेशन परिवर्तन के लिए विशेष मामला

यह संभव है कि उपयोगकर्ता डिवाइस को घुमाएगा या अन्यथा कॉन्फ़िगरेशन परिवर्तन को ट्रिगर करेगा जबकि हमारा अनुमति संवाद अग्रभूमि में है। चूँकि हमारी गतिविधि अभी भी उस संवाद के पीछे दिखाई देती है, हम नष्ट हो जाते हैं और फिर से जुड़ जाते हैं ... लेकिन हम फिर से अनुमति संवाद को फिर से नहीं बढ़ाना चाहते।

यही कारण है कि हमारे पास एक बूलियन है, जिसका नाम है InPermission, यह ट्रैक करता है कि हम अनुमतियों का अनुरोध करने के बीच में हैं या नहीं। हम onSaveInstanceState() में उस मान को onSaveInstanceState() :

@Override
protected void onSaveInstanceState(Bundle outState) {
  super.onSaveInstanceState(outState);
  outState.putBoolean(STATE_IN_PERMISSION, isInPermission);
}

हम इसे onCreate() में पुनर्स्थापित करते हैं। यदि हम सभी वांछित अनुमतियां नहीं रखते हैं, लेकिन IsPermission सत्य है, तो हम अनुमतियों का अनुरोध करना छोड़ देते हैं, क्योंकि हम पहले से ही ऐसा करने के बीच में हैं।


सही। तो मैं अंत में समस्या की तह तक पहुँच गया हूँ: यह एक जगह-जगह ओटीए अपग्रेड था।

मेरे Garmin Fenix ​​2 ब्लूटूथ के माध्यम से कनेक्ट करने में सक्षम नहीं था और "Marshmallow उन्नयन मुद्दों" के बाद googling के बाद मेरा संदेह तेज हो गया। फिर भी, "फ़ैक्टरी रीसेट" ने समस्या को ठीक कर दिया।

आश्चर्यजनक रूप से, रीसेट ने फोन को मूल किटकैट में वापस नहीं किया; इसके बजाय, वाइप प्रक्रिया ने ओटीए डाउनलोड किए गए 6.0 अपग्रेड पैकेज को उठाया और इसके साथ चली, परिणामस्वरूप (मुझे लगता है) "क्लीनर" अपग्रेड में।

बेशक, इसका मतलब यह था कि फोन उन सभी ऐप को खो देता है जिन्हें मैंने इंस्टॉल किया था। लेकिन, बिना किसी बदलाव के (बिना पिछड़े अनुकूलता के) काम करते हुए, नए सिरे से स्थापित किए गए ऐप। वाह!


हो सकता है कि आप अपनी परियोजना में उत्पन्न कोड से प्रकट वर्ग का उपयोग न कर सकें। तो, आप android sdk "android.Manifest.permission.WRITE_EXTERNAL_STORAGE" से मैनिफ़ेस्ट क्लास का उपयोग कर सकते हैं। लेकिन Marsmallow संस्करण में 2 अनुमति देना आवश्यक है भंडारण श्रेणी में WRITE और READ EXTERNAL STORAGE हैं। मेरा कार्यक्रम देखें, मेरा कार्यक्रम अनुमति का अनुरोध करेगा जब तक कि उपयोगकर्ता हां नहीं चुने और अनुमति दिए जाने के बाद कुछ करें।

            if (Build.VERSION.SDK_INT >= 23) {
                if (ContextCompat.checkSelfPermission(LoginActivity.this, android.Manifest.permission.WRITE_EXTERNAL_STORAGE)
                        != PackageManager.PERMISSION_GRANTED || ContextCompat.checkSelfPermission(LoginActivity.this, android.Manifest.permission.READ_EXTERNAL_STORAGE)
                        != PackageManager.PERMISSION_GRANTED) {
                    ActivityCompat.requestPermissions(LoginActivity.this,
                            new String[]{android.Manifest.permission.WRITE_EXTERNAL_STORAGE, android.Manifest.permission.READ_EXTERNAL_STORAGE},
                            1);
                } else {
                    //do something
                }
            } else {
                    //do something
            }





android-6.0-marshmallow