उपयोगकर्ता को छवि के लिए कैमरा या गैलरी का चयन करने की अनुमति दें

Question

मैं जो करने की कोशिश कर रहा हूं वह बहुत सरल लगता है, लेकिन कुछ दिनों की खोज के बाद मैं इसे समझ नहीं पाया।

मेरे पास एक एप्लिकेशन है जो उपयोगकर्ता को कई (5 तक) छवियों का चयन करने की अनुमति देता है। मैं एक का उपयोग कर रहा हूँ ImageView। जब उपयोगकर्ता क्लिक करता है ImageView, तो मैं उन्हें विकल्प की अनुमति देना चाहूंगा

1. गैलरी से छवि का चयन करें, या
2. छवि को कैप्चर करने के लिए कैमरे का उपयोग करें।

मैंने ACTION_GET_CONTENTइरादे का उपयोग करके शुरू किया , और यह गैलरी के लिए अच्छी तरह से काम करता है। तो फिर मैंने ACTION_PICK_ACTIVITYउपयोगकर्ता को कैमरा या गैलरी चुनने की अनुमति देने के इरादे से कोशिश की :

Intent pickIntent = new Intent(Intent.ACTION_PICK_ACTIVITY);
Intent gallIntent=new Intent(Intent.ACTION_GET_CONTENT);
gallIntent.setType("image/*"); 
Intent camIntent = new Intent("android.media.action.IMAGE_CAPTURE");
pickIntent.putExtra(Intent.EXTRA_INTENT, camIntent);
pickIntent.putExtra(Intent.EXTRA_INTENT, gallIntent)
pickIntent.putExtra(Intent.EXTRA_TITLE, "Select Source");
startActivityForResult(pickIntent, IMAGE_SELECTOR);

लेकिन ऐसा लगता है कि मैं केवल एक जोड़ सकता हूं EXTRA_INTENT। मेनू उम्मीद के मुताबिक दिखाई देता है, लेकिन एकमात्र विकल्प गैलरी और फाइलें .... कोई कैमरा नहीं है)।

क्या ऐसा करने का एक बेहतर / आसान तरीका है जो मुझे याद आ रहा है? किसी भी मदद के लिए धन्यवाद।

Comments

FYI करें समान उत्तर, डेविड के शानदार उत्तर के पूरक। stackoverflow.com/a/11676554/294884 फिर से धन्यवाद सभी से डेविड !!!

— फेटी

एक इरादे के साथ इस उत्तर पर एक नज़र डालें जो एक अद्वितीय इरादे में दोनों अनुरोधों (कैमरा और गैलरी) को मिलाता है: stackoverflow.com/a/32475805/2232889

— मारियो वेलास्को

सरल: इस तरह से एक पुस्तकालय का उपयोग करें ।

— वंसुइता जूनियर

Answer 1

आपको अपने स्वयं के चयनकर्ता संवाद बनाने होंगे जो दोनों इरादे संकल्प परिणामों को मिलाते हैं।

ऐसा करने के लिए, आपको दोनों मूल इरादों के लिए PackageManager.queryIntentActivities () के साथ PackageManager को क्वेरी करने की आवश्यकता होगी और इस तरह से प्रत्येक पुनर्प्राप्त गतिविधि के लिए एक नए इरादे के साथ संभावित इरादों की अंतिम सूची बनाएं:

List<Intent> yourIntentsList = new ArrayList<Intent>();

List<ResolveInfo> listCam = packageManager.queryIntentActivities(camIntent, 0);
for (ResolveInfo res : listCam) {
    final Intent finalIntent = new Intent(camIntent);
    finalIntent.setComponent(new ComponentName(res.activityInfo.packageName, res.activityInfo.name));
    yourIntentsList.add(finalIntent);
}

List<ResolveInfo> listGall = packageManager.queryIntentActivities(gallIntent, 0);
for (ResolveInfo res : listGall) {
    final Intent finalIntent = new Intent(gallIntent);
    finalIntent.setComponent(new ComponentName(res.activityInfo.packageName, res.activityInfo.name));
    yourIntentsList.add(finalIntent);
}

(मैंने इसे सीधे यहाँ लिखा है इसलिए यह संकलन नहीं हो सकता है)

फिर, किसी सूची से कस्टम संवाद बनाने के बारे में अधिक जानकारी के लिए देखें https://developer.android.com/guide/topics/ui/dialogs.html#AlertDialog

Answer 2

गैलरी या कैमरा से छवियों का चयन करने के लिए किसी एकल इरादे को कैसे लॉन्च करें, या फाइल सिस्टम ब्राउज़ करने के लिए पंजीकृत कोई भी एप्लिकेशन।

इंटेंट विकल्पों की सूची के साथ एक डायलॉग बनाने के बजाय, विभिन्न 'कैमरा', 'गैलरी' और यहां तक ​​कि तीसरे कंप्यूटर फाइल सिस्टम ब्राउज़र एप्स के छोटे नामों तक पहुंचने के लिए Intent.createChooser का उपयोग करना बेहतर है। जैसे कि 'एस्ट्रो', आदि।

यह बताता है कि मानक चयनकर्ता-इरादे का उपयोग कैसे करें और उस पर अतिरिक्त इरादे जोड़ें।

private Uri outputFileUri;

private void openImageIntent() {

    // Determine Uri of camera image to save.
    final File root = new File(Environment.getExternalStorageDirectory() + File.separator + "MyDir" + File.separator);
    root.mkdirs();
    final String fname = Utils.getUniqueImageFilename();
    final File sdImageMainDirectory = new File(root, fname);
    outputFileUri = Uri.fromFile(sdImageMainDirectory);

    // Camera.
    final List<Intent> cameraIntents = new ArrayList<Intent>();
    final Intent captureIntent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
    final PackageManager packageManager = getPackageManager();
    final List<ResolveInfo> listCam = packageManager.queryIntentActivities(captureIntent, 0);
    for(ResolveInfo res : listCam) {
        final String packageName = res.activityInfo.packageName;
        final Intent intent = new Intent(captureIntent);
        intent.setComponent(new ComponentName(packageName, res.activityInfo.name));
        intent.setPackage(packageName);
        intent.putExtra(MediaStore.EXTRA_OUTPUT, outputFileUri);
        cameraIntents.add(intent);
    }

    // Filesystem.
    final Intent galleryIntent = new Intent();
    galleryIntent.setType("image/*");
    galleryIntent.setAction(Intent.ACTION_GET_CONTENT);

    // Chooser of filesystem options.
    final Intent chooserIntent = Intent.createChooser(galleryIntent, "Select Source");

    // Add the camera options.
    chooserIntent.putExtra(Intent.EXTRA_INITIAL_INTENTS, cameraIntents.toArray(new Parcelable[cameraIntents.size()]));

    startActivityForResult(chooserIntent, YOUR_SELECT_PICTURE_REQUEST_CODE);
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (resultCode == RESULT_OK) {
        if (requestCode == YOUR_SELECT_PICTURE_REQUEST_CODE) {
            final boolean isCamera;
            if (data == null) {
                isCamera = true;
            } else {
                final String action = data.getAction();
                if (action == null) {
                    isCamera = false;
                } else {
                    isCamera = action.equals(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
                }
            }

            Uri selectedImageUri;
            if (isCamera) {
                selectedImageUri = outputFileUri;
            } else {
                selectedImageUri = data == null ? null : data.getData();
            }
        }
    }
}

Comments

बहुत अच्छा! बस एक त्वरित सुधार: पहले दूसरे में iscamera = MediaStore.ACTION_IMAGE_CAPTURE.equals (data.getAction ()); उन सभी पर शासन करने के लिए एक पंक्ति;)

— Glatzial

मेरे मामले final String fname = Utils.getUniqueImageFilename();में काम नहीं कर रहा है ... यह कहता है Utils cannot be resolved:(

— शजील अफ़ज़ल

@ शाजील, Utils.getUniqueImageFilename()एक अद्वितीय फ़ाइल नाम बनाने के लिए मेरा अपना तरीका है। इसे करने के कई तरीके हैं। सबसे सरल में से एक है जैसे कुछ का उपयोग करना "img_"+ System.currentTimeMillis() + ".jpg"। एक और है File.createTempFile()।

— डेविड मैनपूल

यह मेरे लिए बहुत अच्छा काम किया, लेकिन मुझे एक समस्या थी जहां कैमरा का उपयोग स्रोत के रूप में नहीं कर रहा था onActivityResult और कैमरा खुद को खारिज नहीं कर रहा था। मूल कारण प्रकट में एक लापता अनुमति थी: <उपयोग-अनुमति Android: name = "android.permission.WRITE_EXTERNAL_STORAGE" />

— BitsEvolved

जैसा कि रोहन ने कहा, यह 5.1.1 पर बदल जाता है। आपको करने की आवश्यकता होगी if (data == null || data.getData() == null)।

— रयान

Answer 3

मुझे यह मिल गया । का उपयोग करते हुए:

galleryIntent.setType("image/*");
galleryIntent.setAction(Intent.ACTION_GET_CONTENT);

किसी एक इरादे के लिए उपयोगकर्ता को एंड्रॉइड 4 में 'डॉक्यूमेंट्स' चुनने का विकल्प दिखाई देता है, जो मुझे बहुत भ्रामक लगा। इसके बजाय इसका उपयोग करना 'गैलरी' विकल्प दिखाता है:

Intent pickIntent = new Intent(Intent.ACTION_PICK, MediaStore.Images.Media.EXTERNAL_CONTENT_URI);

Comments

यह ठीक काम करता है..लेकिन जब हम कैमरा इमेज, पोर्ट्रेट इमेज शो को लैंडस्केप मोड में ब्राउज़ करते हैं ..

@ user5060065 और अन्य को चयनित चित्र के उन्मुखीकरण में समस्या है, सही अभिविन्यास प्राप्त करने के लिए stackoverflow.com/a/6931373/1975002 देखें , और यदि आवश्यक हो तो इसे घुमाएं।

— माइकेल पोला

Answer 4

मेरे पास यह मुद्दा भी था और मैंने जो किया वह एक अलर्टडायॉग बनाया और डायलॉगइंटरफेस श्रोता के साथ सेट इट्स () विधि का उपयोग किया:

AlertDialog.Builder getImageFrom = new AlertDialog.Builder(Fotos.this);
getImageFrom.setTitle("Select:");
final CharSequence[] opsChars = {getResources().getString(R.string.takepic), getResources().getString(R.string.opengallery)};
getImageFrom.setItems(opsChars, new android.content.DialogInterface.OnClickListener(){

    @Override
    public void onClick(DialogInterface dialog, int which) {
        if(which == 0){
            Intent cameraIntent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
            startActivityForResult(cameraIntent, CAMERA_PIC_REQUEST);
        }else
            if(which == 1){
                Intent intent = new Intent();
                intent.setType("image/*");
                intent.setAction(Intent.ACTION_GET_CONTENT);
                startActivityForResult(Intent.createChooser(intent,
                    getResources().getString(R.string.pickgallery)), SELECT_PICTURE);
            }
        dialog.dismiss();
    }
});

Answer 5

मैंने गैलरी या कैमरा से एक छवि चुनने के लिए एक पूर्ण उपयोग करने के लिए कुछ समाधानों को विलय कर दिया है। ये ImagePicker उपयोग की विशेषताएं हैं ( जीथब लिब में भी ):

• गैलरी और कैमरा के लिए मर्ज किए गए इरादे।
• चयनित बड़ी छवियों का आकार बदलें (उदाहरण: 2500 x 1600)
• अगर बारीक छवि है तो घुमाएँ

स्क्रीनशॉट:

संपादित करें : यहां गैलरी और कैमरा ऐप्स के लिए एक मर्ज किए गए इरादे को एक साथ प्राप्त करने के लिए कोड का एक टुकड़ा है। आप ImagePicker के उपयोग में पूरा कोड देख सकते हैं (एक गिथब लिब में भी ):

public static Intent getPickImageIntent(Context context) {
    Intent chooserIntent = null;

    List<Intent> intentList = new ArrayList<>();

    Intent pickIntent = new Intent(Intent.ACTION_PICK,
            android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
    Intent takePhotoIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
    takePhotoIntent.putExtra("return-data", true);
    takePhotoIntent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(getTempFile(context)));
    intentList = addIntentsToList(context, intentList, pickIntent);
    intentList = addIntentsToList(context, intentList, takePhotoIntent);

    if (intentList.size() > 0) {
        chooserIntent = Intent.createChooser(intentList.remove(intentList.size() - 1),
                context.getString(R.string.pick_image_intent_text));
        chooserIntent.putExtra(Intent.EXTRA_INITIAL_INTENTS, intentList.toArray(new Parcelable[]{}));
    }

    return chooserIntent;
}

private static List<Intent> addIntentsToList(Context context, List<Intent> list, Intent intent) {
    List<ResolveInfo> resInfo = context.getPackageManager().queryIntentActivities(intent, 0);
    for (ResolveInfo resolveInfo : resInfo) {
        String packageName = resolveInfo.activityInfo.packageName;
        Intent targetedIntent = new Intent(intent);
        targetedIntent.setPackage(packageName);
        list.add(targetedIntent);
    }
    return list;
}

Comments

यह वास्तव में अच्छी तरह से काम करता है। धन्यवाद। केवल एक समस्या यह है कि चित्र में कैमरे के साथ ली गई तस्वीरें परिदृश्य के रूप में दिखाई दे रही हैं। आवश्यक छवियों को घुमाने के लिए मुझे क्या करने की आवश्यकता है?

— 365SplendidSuns

@ 365SplendidSuns क्या आप जाँच कर सकते हैं कि यह विधि में प्रवेश कर रहा है getRotationFromCamera( ImagePicker.java) और क्या मान लौटा रहा है? आप किस फ़ोन में परीक्षण कर रहे हैं?

— मारियो वेलास्को

मैं एक सोनी एक्सपीरिया सी और एंड्रॉइड स्टूडियो एमुलेटर का उपयोग कर रहा हूं। मैंने अभी कुछ ब्रेक पॉइंट्स में बात की है जो आपके बारे में पूछी गई चीजों की जाँच करने के लिए है और ऐसा लगता है कि बूलियन isCamera getRotation पद्धति में गलत है जो getRotationFromCamera को बुलाया जाने से रोक रहा है।

— 365SplendidSuns

आप किस Android संस्करण की कोशिश कर रहे हैं? मैंने पिछले हफ्ते लाइन 58 पर एक संशोधन जोड़ा, अगर यह हल हो गया तो जांचें:boolean isCamera = (imageReturnedIntent == null || imageReturnedIntent.getData() == null);

— मारियो वेलास्को

ठीक है, एमुलेटर 6.0 संस्करण है और ऐसा लगता है कि लाइन 58 इस पर ठीक काम कर रही है। एमुलेटर पर isCamera सच है और getRotationFromCamera को ठीक कहा जा रहा है, लेकिन int ओरिएंटेशन 0 है जिसका अर्थ है getRotationFromCamera 0 लौट रहा है ... Sony डिवाइस एंड्रॉइड 4.2 का उपयोग कर रहा है और इस पर न तो ImageRetededIntent या imageReturnedIntent.getData () लाइन 58 पर शून्य है। अर्थ .Camera झूठ है और मैं getRotationFromCamera के रूप में दूर के रूप में नहीं मिल रहा है।

— 365SplendidSuns

Answer 6

यह कोड आपकी सहायता करेगा, इसमें कैमरा के लिए दो बटन एक और गैलरी के लिए एक और छवि ImageView में प्रदर्शित किया जाएगा

https://github.com/siddhpuraamitr/Choose-Image-From-Gallery-Or-Camera

Comments

हालांकि यह लिंक प्रश्न का उत्तर दे सकता है, लेकिन उत्तर के आवश्यक भागों को शामिल करना और संदर्भ के लिए लिंक प्रदान करना बेहतर है। लिंक-केवल उत्तर अमान्य हो सकते हैं यदि लिंक किए गए पृष्ठ में परिवर्तन होता है

— MrEngineer13

Answer 7

छवि चयन का उपयोग करते समय 4.4 ऊपर की ओर त्रुटि प्राप्त करने वालों के लिए नीचे दिए गए कोड का उपयोग कर सकते हैं।

इंटेंट विकल्पों की सूची के साथ एक डायलॉग बनाने के बजाय, विभिन्न 'कैमरा', 'गैलरी' और यहां तक ​​कि तीसरे कंप्यूटर फाइल सिस्टम ब्राउज़र एप्स के छोटे नामों तक पहुंचने के लिए Intent.createChooser का उपयोग करना बेहतर है। जैसे कि 'एस्ट्रो', आदि।

यह बताता है कि मानक चयनकर्ता-इरादे का उपयोग कैसे करें और उस पर अतिरिक्त इरादे जोड़ें।

private void openImageIntent(){

    // Determine Uri of camera image to save.
    final File root = new File(Environment.getExternalStorageDirectory() + File.separator + "amfb" + File.separator);
    root.mkdir();
    final String fname = "img_" + System.currentTimeMillis() + ".jpg";
    final File sdImageMainDirectory = new File(root, fname);
    outputFileUri = Uri.fromFile(sdImageMainDirectory);

    // Camera.
    final List<Intent> cameraIntents = new ArrayList<Intent>();
    final Intent captureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
    final PackageManager packageManager = getPackageManager();
    final List<ResolveInfo> listCam = packageManager.queryIntentActivities(captureIntent, 0);
    for (ResolveInfo res : listCam){
        final String packageName = res.activityInfo.packageName;
        final Intent intent = new Intent(captureIntent);
        intent.setComponent(new ComponentName(res.activityInfo.packageName, res.activityInfo.name));
        intent.setPackage(packageName);
        intent.putExtra(MediaStore.EXTRA_OUTPUT, outputFileUri);
        cameraIntents.add(intent);
    }

    //FileSystem
    final Intent galleryIntent = new Intent();
    galleryIntent.setType("image/");
    galleryIntent.setAction(Intent.ACTION_GET_CONTENT);

    // Chooser of filesystem options.
    final Intent chooserIntent = Intent.createChooser(galleryIntent, "Select Source");
    // Add the camera options.
    chooserIntent.putExtra(Intent.EXTRA_INITIAL_INTENTS, cameraIntents.toArray(new Parcelable[]{}));
    startActivityForResult(chooserIntent, CAMERA_CAPTURE_IMAGE_REQUEST_CODE);

}


@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    //super.onActivityResult(requestCode, resultCode, data);
    if (resultCode == RESULT_OK) {
        if (requestCode == CAMERA_CAPTURE_IMAGE_REQUEST_CODE) {
            final boolean isCamera;
            if (data == null) {
                isCamera = true;
            } else {
                final String action = data.getAction();
                if (action == null) {
                    isCamera = false;
                } else {
                    isCamera = action.equals(MediaStore.ACTION_IMAGE_CAPTURE);
                }
            }

            Uri selectedImageUri;
            if (isCamera) {
                selectedImageUri = outputFileUri;
                //Bitmap factory
                BitmapFactory.Options options = new BitmapFactory.Options();
                // downsizing image as it throws OutOfMemory Exception for larger
                // images
                options.inSampleSize = 8;
                final Bitmap bitmap = BitmapFactory.decodeFile(selectedImageUri.getPath(), options);
                preview.setImageBitmap(bitmap);
            } else {
                selectedImageUri = data == null ? null : data.getData();
                Log.d("ImageURI", selectedImageUri.getLastPathSegment());
                // /Bitmap factory
                BitmapFactory.Options options = new BitmapFactory.Options();
                // downsizing image as it throws OutOfMemory Exception for larger
                // images
                options.inSampleSize = 8;
                try {//Using Input Stream to get uri did the trick
                    InputStream input = getContentResolver().openInputStream(selectedImageUri);
                    final Bitmap bitmap = BitmapFactory.decodeStream(input);
                    preview.setImageBitmap(bitmap);
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                }
            }
        }
    } else if (resultCode == RESULT_CANCELED){
        // user cancelled Image capture
        Toast.makeText(getApplicationContext(),
                "User cancelled image capture", Toast.LENGTH_SHORT)
                .show();
    } else {
        // failed to capture image
        Toast.makeText(getApplicationContext(),
                "Sorry! Failed to capture image", Toast.LENGTH_SHORT)
                .show();
    }
}

Comments

नमस्ते। मैंने आपके समाधान की कोशिश की है, लेकिन

मेरे मार्शमैलो डिवाइस पर यह कैमरे का उपयोग करते समय गड़बड़ करता है। मेरे लिए डेटा अशक्त नहीं है, लेकिन एक्शन है, जिससे कॅमेरा को गलत पर सेट किया जा सकता है।

— JStephen

Answer 8

यह टीना के अशक्त आउटपुट का ध्यान रखना चाहिएफिलेयूरी मुद्दा:

private static final String STORED_INSTANCE_KEY_FILE_URI = "output_file_uri";

@Override
public void onSaveInstanceState( Bundle outState ) {
    super.onSaveInstanceState( outState );

    if ( outputFileUri != null ) {
        outState.putString( STORED_INSTANCE_KEY_FILE_URI, outputFileUri.toString() );
    }
}

@Override
public void onViewStateRestored( Bundle savedInstanceState ) {
    super.onViewStateRestored( savedInstanceState );

    if ( savedInstanceState != null ) {
      final String outputFileUriStr = savedInstanceState.getString( STORED_INSTANCE_KEY_FILE_URI );
      if ( outputFileUriStr != null && !outputFileUriStr.isEmpty() ) {
          outputFileUri = Uri.parse( outputFileUriStr );
      }
    }
}

नोट: मैं android.support.v4.app के अंदर इस कोड का उपयोग कर रहा हूं। आपके ओवरराइड तरीकों को बदल सकते हैं जो आपके द्वारा उपयोग किए जा रहे Fragment / गतिविधि संस्करण के आधार पर बदल सकते हैं।

Answer 9

आप विकल्प संवाद बना सकते हैं

कैमरा खोलो:

Intent cameraIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                        cameraIntent.putExtra(MediaStore.EXTRA_OUTPUT,
                                MediaStore.Images.Media.EXTERNAL_CONTENT_URI.toString());
                        if (cameraIntent.resolveActivity(getActivity().getPackageManager()) != null) {
                            startActivityForResult(cameraIntent, CAMERA_IMAGE);
                        }

ओपन गैलरी:

if (Build.VERSION.SDK_INT <= 19) {
            Intent i = new Intent();
            i.setType("image/*");
            i.setAction(Intent.ACTION_GET_CONTENT);
            i.addCategory(Intent.CATEGORY_OPENABLE);
            startActivityForResult(i, GALLARY_IMAGE);
        } else if (Build.VERSION.SDK_INT > 19) {
            Intent intent = new Intent(Intent.ACTION_PICK, android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
            startActivityForResult(intent, GALLARY_IMAGE);
        }

चयन परिणाम प्राप्त करने के लिए

@Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (resultCode == Activity.RESULT_OK) {
            if (requestCode == GALLARY_IMAGE) {
                Uri selectedImageUri = data.getData();
                String selectedImagePath = getRealPathFromURI(selectedImageUri);
            } else if (requestCode == CAMERA_IMAGE) {
                Bundle extras = data.getExtras();
                Bitmap bmp = (Bitmap) extras.get("data");
                SaveImage(bmp);
            }
        }
    }

 public String getRealPathFromURI(Uri uri) {
        if (uri == null) {
            return null;
        }
        String[] projection = {MediaStore.Images.Media.DATA};
        Cursor cursor = getActivity().getContentResolver().query(uri, projection, null, null, null);
        if (cursor != null) {
            int column_index = cursor
                    .getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
            cursor.moveToFirst();
            return cursor.getString(column_index);
        }
        return uri.getPath();
    }

कैप्चर की गई इमेज को सेव करने का तरीका

 private void SaveImage(final Bitmap finalBitmap) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                String root = Environment.getExternalStorageDirectory().toString();

                File myDir = new File(root + "/Captured Images/");
                if (!myDir.exists())
                    myDir.mkdirs();

                String fname = "/image-" + System.currentTimeMillis() + ".jpg";
                File file = new File(myDir, fname);
                try {
                    FileOutputStream out = new FileOutputStream(file);
                    finalBitmap.compress(Bitmap.CompressFormat.JPEG, 100, out);
                    out.flush();
                    out.close();
                    localImagePath = myDir + fname;
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }


        });
        t.start();

    }

Answer 10

बहुत बड़ी छवि समस्या का समाधान किया और स्मृति से बाहर जाने से बचें।

    private static final int SELECT_PICTURE = 0;
    private static final int REQUEST_CAMERA = 1;
    private ImageView mImageView;

    private void selectImage() {
        final CharSequence[] items = {"Take Photo", "Choose from Library",
                "Cancel"};
        AlertDialog.Builder builder = new AlertDialog.Builder(mContext);
        builder.setTitle("Add Photo!");
        builder.setItems(items, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int item) {
                if (items[item].equals("Take Photo")) {
                    Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                    File f = new File(android.os.Environment
                            .getExternalStorageDirectory(), "temp.jpg");
                    intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(f));
                    startActivityForResult(intent, REQUEST_CAMERA);
                } else if (items[item].equals("Choose from Library")) {
                    Intent intent = new Intent(
                            Intent.ACTION_PICK, android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
                    intent.setType("image/*");
                    startActivityForResult(
                            Intent.createChooser(intent, "Select File"),
                            SELECT_PICTURE);
                } else if (items[item].equals("Cancel")) {
                    dialog.dismiss();
                }
            }
        });
        builder.show();
    }
    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (resultCode == Activity.RESULT_OK) {
            if (requestCode == REQUEST_CAMERA) {
                File f = new File(Environment.getExternalStorageDirectory()
                        .toString());
                for (File temp : f.listFiles()) {
                    if (temp.getName().equals("temp.jpg")) {
                        f = temp;
                        break;
                    }
                }
                try {
                    Bitmap bm;
                    BitmapFactory.Options btmapOptions = new BitmapFactory.Options();
                    btmapOptions.inSampleSize = 2;
                    bm = BitmapFactory.decodeFile(f.getAbsolutePath(),
                            btmapOptions);

                    // bm = Bitmap.createScaledBitmap(bm, 70, 70, true);
                    mImageView.setImageBitmap(bm);

                    String path = android.os.Environment
                            .getExternalStorageDirectory()
                            + File.separator
                            + "test";
                    f.delete();
                    OutputStream fOut = null;
                    File file = new File(path, String.valueOf(System
                            .currentTimeMillis()) + ".jpg");
                    fOut = new FileOutputStream(file);
                    bm.compress(Bitmap.CompressFormat.JPEG, 85, fOut);
                    fOut.flush();
                    fOut.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            } else if (requestCode == SELECT_PICTURE) {
                Uri selectedImageUri = data.getData();
                String tempPath = getPath(selectedImageUri, this.getActivity());
                Bitmap bm;
                btmapOptions.inSampleSize = 2;
                BitmapFactory.Options btmapOptions = new BitmapFactory.Options();
                bm = BitmapFactory.decodeFile(tempPath, btmapOptions);
                mImageView.setImageBitmap(bm);
            }
        }
    }
    public String getPath(Uri uri, Activity activity) {
        String[] projection = {MediaStore.MediaColumns.DATA};
        Cursor cursor = activity
                .managedQuery(uri, projection, null, null, null);
        int column_index = cursor.getColumnIndexOrThrow(MediaStore.MediaColumns.DATA);
        cursor.moveToFirst();
        return cursor.getString(column_index);
    }

Answer 11

मेरा समाधान जोड़ना - यह एक कॉलबैक लौटाएगा चाहे वह कैमरे से हो या गैली से इरादे के साथ हो:

public class ImagePickerManager extends BaseAdapter {

private List<ResolveInfo> mApplications;
private TreeSet<Integer> mImageCaptureIntents;
private TreeSet<Integer> mImagePickerIntents;
private Context mContext;
private final ImagePickerManagerListener listener;

private static enum intentType {
    choosePhoto,
    takePhoto,
    unknown;

    public int getIntValue() {
        switch (this) {
            case choosePhoto:
                return 0;
            case takePhoto:
                return 1;
            case unknown:
                return 2;
        }
        return 0;
    }
}

public interface ImagePickerManagerListener {
    void onChooseImage(Intent intent);
    void onCaptureImage(Intent intent);
}

public ImagePickerManager(Context context,ImagePickerManagerListener listenr) {
    this.mContext = context;
    this.listener = listenr;

    mImageCaptureIntents = new TreeSet<>();
    mImagePickerIntents = new TreeSet<>();

    //Picking photo intent
    Intent intent = new Intent(Intent.ACTION_PICK);
    intent.setType("image/*");
    mApplications = mContext.getPackageManager().queryIntentActivities(intent, 0);

    int index = 0;
    for (int i = 0; i < mApplications.size(); i++) {
        mImagePickerIntents.add(index);
        index++;
    }

    //Capture photo intent
    intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
    List<ResolveInfo> resolveInfoList = mContext.getPackageManager().queryIntentActivities(intent, 0);
    mApplications.addAll(resolveInfoList);
    for (int i = 0; i < mApplications.size(); i++) {
        mImageCaptureIntents.add(index);
        index++;
    }
}

public static void openChooseAndCaptureImageDialog(final Context context, final ImagePickerManagerListener listener) {

    Log.d("openChooseAndCaptureImageDialog", "enter");

    final AlertDialog.Builder builder = new AlertDialog.Builder(context);
    final ImagePickerManager imagePickerManager = new ImagePickerManager(context,listener);
    builder.setTitle(context.getString(R.string.image_picker_dialog_box_title));
    builder.setAdapter(imagePickerManager, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialoginterface, int i) {
            ResolveInfo resolveInfo = (ResolveInfo) imagePickerManager.getItem(i);
            Intent pickerIntent = imagePickerManager.getIntentForPackage(context,resolveInfo,i);
            switch (imagePickerManager.getIntentType(i)){
                case choosePhoto:
                    listener.onChooseImage(pickerIntent);
                    break;
                case takePhoto:
                    listener.onCaptureImage(pickerIntent);
                    break;
                case unknown:
                    break;
            }
        }
    });

    builder.setCancelable(true);
    builder.setInverseBackgroundForced(true);
    AlertDialog dialog = builder.create();
    dialog.show();
}


private intentType getIntentType(int index) {

    if (mImageCaptureIntents.contains(index)) {
       return intentType.takePhoto;
    } else if(mImagePickerIntents.contains(index)) {
        return intentType.choosePhoto;
    }
    return intentType.unknown;
}

private Intent getIntentForPackage(Context context, ResolveInfo info,int index) {
    Intent intent = context.getPackageManager().getLaunchIntentForPackage(info.activityInfo.packageName);

    ComponentName chosenName = new ComponentName(
            info.activityInfo.packageName,
            info.activityInfo.name);

    intent.setComponent(chosenName);
    intent.setFlags(Intent.FLAG_ACTIVITY_TASK_ON_HOME);
    if (mImageCaptureIntents.contains(index)) {
        intent.setAction(MediaStore.ACTION_IMAGE_CAPTURE);
    } else if(mImagePickerIntents.contains(index)) {
        intent.setType("image/*");
        intent.setAction(Intent.ACTION_PICK);
    }
    return intent;
}

@Override
public int getCount() {
    return mApplications.size();
}

@Override
public Object getItem(int position) {
    return mApplications.get(position);
}

@Override
public long getItemId(int position) {
    return position;
}

@Override
public View getView(int position, View convertView, ViewGroup parent) {
    ResolveInfo item = mApplications.get(position);
    if (convertView == null) {
        TextView applicationTextView = new TextView(mContext);
        LayoutParams param = new LayoutParams(
                LayoutParams.MATCH_PARENT,
                LayoutParams.WRAP_CONTENT);
        applicationTextView.setLayoutParams(param);
        final int horizontalPadding = (int) FVRGeneralUtils.convertDpToPx(mContext, 15);
        final int verticalPadding = (int) FVRGeneralUtils.convertDpToPx(mContext, 5);
        applicationTextView.setPadding(horizontalPadding,verticalPadding, horizontalPadding, verticalPadding);
        applicationTextView.setGravity(android.view.Gravity.CENTER_VERTICAL);
        Resources.Theme th = mContext.getTheme();
        TypedValue tv = new TypedValue();

        if (th.resolveAttribute(android.R.attr.textAppearanceMedium, tv, true)) {
            applicationTextView.setTextAppearance(mContext, tv.resourceId);
        }

        applicationTextView.setMinHeight((int) FVRGeneralUtils.convertDpToPx(mContext, 25));
        applicationTextView.setCompoundDrawablePadding((int) FVRGeneralUtils.convertDpToPx(mContext, 7));
        convertView = applicationTextView;
    }

    TextView textView = (TextView) convertView;
    textView.setText(item.loadLabel(mContext.getPackageManager()));
    textView.setCompoundDrawablesWithIntrinsicBounds(item.loadIcon(mContext.getPackageManager()), null, null, null);
    return textView;
} }

Answer 12

आप यह कोशिश कर सकते हैं:

गैलरी खोलने के लिए:

private void browseImage() {

        try {
  Intent galleryIntent = new Intent(Intent.ACTION_PICK,
                    android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
  startActivityForResult(galleryIntent, GALLERY_IMAGE_PICK); //GALLERY_IMAGE_PICK it is a string
  } catch (Exception e) {}
     }

कैमरा खोलने के लिए:

 private void captureImage() {
    Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);

    fileUri = getOutputMediaFileUri(MEDIA_TYPE_IMAGE);

    intent.putExtra(MediaStore.EXTRA_OUTPUT, fileUri);

    // start the image capture Intent

    startActivityForResult(intent, CAMERA_CAPTURE_IMAGE_REQUEST_CODE);

}

Comments

यह SO पर कहीं और से एक पेस्ट है। उदाहरण के लिए - getOutputMediaFileUri क्या करता है? कृपया स्पष्टीकरण के साथ पूर्ण उदाहरण साझा करें।

— किलोकाहन

Answer 13

यह AlertDialog और Intent.ACTION_PICK का उपयोग करके सरल है

    //camOption is a string array contains two items (Camera, Gallery)
    AlertDialog.Builder builder = new AlertDialog.Builder(CarPhotos.this);
    builder.setTitle(R.string.selectSource)
    .setItems(R.array.imgOption, new DialogInterface.OnClickListener() {

    public void onClick(DialogInterface dialog, int which)

     {

        if (which==0) {
        Intent intent = new Intent(this, CameraActivity.class);
        startActivityForResult(intent, REQ_CAMERA_IMAGE);               }

        if (which==1) {
        Intent i = new Intent(Intent.ACTION_PICK,android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
        startActivityForResult(i, RESULT_LOAD_IMAGE);
            }

     }
            });
             builder.create();
             builder.show();

Answer 14

डेविड के जवाब पर, मेरी ओर से दो पैसे onActivityResult()का निर्माण। यह 5.1.1 में शुरू किए गए परिवर्तनों का ध्यान रखता है और यह पता लगाता है कि क्या उपयोगकर्ता ने लाइब्रेरी से एक या एक से अधिक छवि ली है।

private enum Outcome {
    camera, singleLibrary, multipleLibrary, unknown
}

/**
 * Returns a List<Uri> containing the image uri(s) chosen by the user
 *
 * @param data      The data intent coming from the onActivityResult()
 * @param cameraUri The uri that had been passed to the intent when the chooser was invoked.
 * @return A List<Uri>, never null.
 */
public List<Uri> getPicturesUriFromIntent(Intent data, Uri cameraUri) {

    Outcome outcome = Outcome.unknown;

    if (data == null || (data.getData() == null && data.getClipData() == null)) {
        outcome = Outcome.camera;
    } else if (data.getData() != null && data.getClipData() == null) {
        outcome = Outcome.singleLibrary;
    } else if (data.getData() == null) {
        outcome = Outcome.multipleLibrary;
    } else {
        final String action = data.getAction();
        if (action != null && action.equals(MediaStore.ACTION_IMAGE_CAPTURE)) {
            outcome = Outcome.camera;
        }
    }

    // list the uri(s) we got back
    List<Uri> uris = new ArrayList<>();
    switch (outcome) {
        case camera:
            uris.add(cameraUri);
            break;

        case singleLibrary:
            uris.add(data.getData());
            break;

        case multipleLibrary:
            final ClipData clipData = data.getClipData();
            for (int i = 0; i < clipData.getItemCount(); i++) {
                ClipData.Item item = clipData.getItemAt(i);
                uris.add(item.getUri());
            }
            break;
    }

    return uris;
}

Answer 15

इस तरह आजमाएं

final CharSequence[] items = { "Take Photo", "Choose from Library",
            "Cancel" };

    AlertDialog.Builder builder = new AlertDialog.Builder(MainActivity.this);
    builder.setTitle("Add Photo!");
    builder.setItems(items, new DialogInterface.OnClickListener() {
        @Override
        public void onClick(DialogInterface dialog, int item) {
            if (items[item].equals("Take Photo")) {
                Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                File f = new File(android.os.Environment
                        .getExternalStorageDirectory(), "temp.jpg");
                intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(f));
                startActivityForResult(intent, REQUEST_CAMERA);
            } else if (items[item].equals("Choose from Library")) {
                Intent intent = new Intent(
                        Intent.ACTION_PICK,
                        android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
                intent.setType("image/*");
                startActivityForResult(
                        Intent.createChooser(intent, "Select File"),
                        SELECT_FILE);
            } else if (items[item].equals("Cancel")) {
                dialog.dismiss();
            }
        }
    });
    builder.show();

फिर onactivityresult विधि बनाएं और ऐसा कुछ करें

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (resultCode == RESULT_OK) {
        if (requestCode == REQUEST_CAMERA) {
            File f = new File(Environment.getExternalStorageDirectory()
                    .toString());
            for (File temp : f.listFiles()) {
                if (temp.getName().equals("temp.jpg")) {
                    f = temp;
                    break;
                }
            }
            try {
                Bitmap bm;
                BitmapFactory.Options btmapOptions = new BitmapFactory.Options();

                bm = BitmapFactory.decodeFile(f.getAbsolutePath(),
                        btmapOptions);

                // bm = Bitmap.createScaledBitmap(bm, 70, 70, true);
                ivImage.setImageBitmap(bm);

                String path = android.os.Environment
                        .getExternalStorageDirectory()
                        + File.separator
                        + "Phoenix" + File.separator + "default";
                f.delete();
                OutputStream fOut = null;
                File file = new File(path, String.valueOf(System
                        .currentTimeMillis()) + ".jpg");
                try {
                    fOut = new FileOutputStream(file);
                    bm.compress(Bitmap.CompressFormat.JPEG, 85, fOut);
                    fOut.flush();
                    fOut.close();
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        } else if (requestCode == SELECT_FILE) {
            Uri selectedImageUri = data.getData();

            String tempPath = getPath(selectedImageUri, MainActivity.this);
            Bitmap bm;
            BitmapFactory.Options btmapOptions = new BitmapFactory.Options();
            bm = BitmapFactory.decodeFile(tempPath, btmapOptions);
            ivImage.setImageBitmap(bm);
        }
    }
}

इसे देखें http://www.theappguruz.com/blog/android-take-photo-camera-gallery-code-sample

Answer 16

Android में छवि के लिए कैमरा या गैलरी का चयन करना

मैंने कैमरा या गैलरी छवि चयन पर कड़ी मेहनत की , और इस काम के लिए कुछ उपयोग वर्ग बनाया। इन वर्ग के उपयोग के साथ 'सेलेक्टिंग इमेज कैमरा या गैलरी बहुत आसान है', यह सिर्फ आपके विकास के 5-10 टकसालों को ले गया।

चरण -1: इन कक्षाओं को अपने कोड में जोड़ें।

ImagePickerUtils: - http://www.codesend.com/view/f8f7c637716bf1c693d1490635ed49b3/

बिटमैप युटिल्स: - http://www.codesend.com/view/81c1c2a3f39f1f7e627f01f67be282cf/

ConvertUriToFilePath: - http://www.codesend.com/view/f4668a29860235dd1b66eb419c5a58b5/

MediaUtils: - https://codeshare.io/5vKEMl

हमें इन अनुमति को मेनिफेस्ट में जोड़ने की आवश्यकता है:

  <uses-permission android:name="android.permission.CAMERA" />
  <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
  <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
  <uses-feature android:name="android.hardware.camera" />
  <uses-feature android:name="android.hardware.camera.autofocus" />

यह क्लास फ़ंक्शन (checkAndRequestPims) ऑटो एंड्रॉइड- मार्शमैलो और एंड्रॉइड - नौगाट में अनुमति की जांच करता है ।

चरण 2। कैमरा आशय लॉन्च करने के लिए कैमरा क्लास कॉलिंग:

 //Create a global veriable .  
     private Uri mCameraUri;
     private static final int CAMERA_REQUEST_CODE = 100;

// Call this function when you wants to select or capture an Image.
       mCameraUri = ImagePickerUtils.createTakePictureIntent(this, CAMERA_REQUEST_CODE);

चरण -3: आशय से डेटा प्राप्त करने के लिए अपनी गतिविधि में onActivityResult जोड़ें

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (resultCode == Activity.RESULT_OK) {
            Uri fileUri = ImagePickerUtils.getFileUriOfImage(this, data, mCameraUri);
            try {
                Bitmap bitmap = null;
                if (CAMERA_REQUEST_CODE == requestCode) {
                    bitmap = new BitmapUtils().getDownsampledBitmap(this, fileUri, imageView.getWidth(), imageView.getHeight());
                }
                if (bitmap != null)
                imageView.setImageBitmap(bitmap);

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

मुझे आशा है कि यह आपकी मदद करता है, यदि कोई भी इन वर्ग को बेहतर बनाने के लिए कोई सुझाव देता है तो कृपया अपनी समीक्षा टिप्पणियों में जोड़ें।

Comments

इसकी एक समस्या है। क्लास मीडियायूटल जो बिटमैप यूटिल्स और इमेजपिक्युटिल्स में उपयोग किया जाता है?

— रोजर RV

@RogerRV, मुझे सूचित करने के लिए धन्यवाद, मैंने अभी नई कक्षा फ़ाइल के साथ उत्तर अपडेट किया है।

— A-Droid Tech

आपके लिए धन्यवाद, मैं इसे अभी देखूंगा। मैंने इसे अपने लिए हल करने की कोशिश की लेकिन यह काम नहीं करता है

— रोजर आरवी

Answer 17

डेविड मैनपियर जवाब के अनुसार
https://stackoverflow.com/a/12347567/7226732

हम सिर्फ संशोधित करने की आवश्यकता onActivityResult () की तरह

 protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (resultCode == RESULT_OK) {
        if (requestCode == YOUR_SELECT_PICTURE_REQUEST_CODE) {
            final boolean isCamera;
            if (data.getExtras() == null) {
                isCamera = true;
            } else {
                final String action = data.getAction();
                if (action == null) {
                    isCamera = false;
                } else {
                    isCamera = action.equals(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
                }
            }
            Uri selectedImageUri;
            if (isCamera) {
                selectedImageUri = fileUri;
                try {
                    Bitmap bitmap = MediaStore.Images.Media.getBitmap(this.getContentResolver(), selectedImageUri);
                    Toast.makeText(CreateWaterType.this, "Image Saved!", Toast.LENGTH_SHORT).show();
                    image_view.setImageBitmap(bitmap);

                } catch (IOException e) {
                    e.printStackTrace();
                    Toast.makeText(CreateWaterType.this, "Failed!", Toast.LENGTH_SHORT).show();
                }

            } else {
                selectedImageUri = data == null ? null : data.getData();
                try {
                    Bitmap bitmap = MediaStore.Images.Media.getBitmap(this.getContentResolver(), selectedImageUri);

                    Toast.makeText(CreateWaterType.this, "Image Saved!", Toast.LENGTH_SHORT).show();
                    image_view.setImageBitmap(bitmap);

                } catch (IOException e) {
                    e.printStackTrace();
                    Toast.makeText(CreateWaterType.this, "Failed!", Toast.LENGTH_SHORT).show();
                }
            }
        }
    }
}

और छवि दृश्य में छवियों को कैप्चर या पिक करें।