एंड्रॉइड: कोटलिन का उपयोग करके फोटो कैसे लें

इस प्लेटफ़ॉर्म में अपने पहले लेख के लिए मैं यह समझाना चाहता हूं कि आप कैमरा ऐप का उपयोग करके एंड्रॉइड में फोटो कैसे ले सकते हैं और परिणामस्वरूप आपके एप्लिकेशन में छवि प्राप्त कर सकते हैं। यह सब प्रोग्रामिंग भाषा के रूप में कोटलिन का उपयोग करता है।

पहले हमें एंड्रॉइड स्टूडियो में एक नई परियोजना बनाने की आवश्यकता है। इस उदाहरण के लिए मैं Android Studio 2.3.3 का उपयोग कर रहा हूं।

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

कुछ कदमों को सरल बनाने के लिए इस परियोजना में मैं कुछ पुस्तकालयों का उपयोग कर रहा हूं, जैसे कि दृश्य बंधन, चित्र प्रदर्शित करना और अनुमति देना:

  • बाइंडिंग के लिए मैंने बटरकाइफ़ का इस्तेमाल किया: http://jakewharton.github.io/butterknife/
  • अनुमति अनुरोध के लिए मैंने डेक्सटर को शामिल किया: https://github.com/Karumi/Dexter
  • चित्र प्रदर्शित करने के लिए मैंने फ्रेस्को का उपयोग किया: http://frescolib.org/

अगला कदम हमारे एंड्रॉइड मेनीफेस्ट में निर्दिष्ट करना है कि हमारे ऐप को किन अनुमतियों की आवश्यकता है। इस मामले में हमें android.permission.WRITE_EXTERNAL_STORAGE की जरूरत पड़ने वाली है।

<उपयोग-अनुमति android: नाम = "android.permission.WRITE_EXTERNAL_STORAGE" />

आइए हमारी मुख्य गतिविधि के लिए लेआउट बनाएं





    

    

स्क्रीन इस तरह दिखाई देगी:

मुख्य गतिविधि

MainActivity.kt फ़ाइल में, हम फ़्लोटिंग एक्शन बटन पर एक क्लिक श्रोता सेट करने जा रहे हैं ताकि उपयोगकर्ता कैमरा ऐप को उस पर टैप कर सके।

मस्ती को ओवररिएट करें (सेवइंस्टेंसस्टैट: बंडल?) ???
    super.onCreate (savedInstanceState)
    setContentView (R.layout.activity_main)
    ButterKnife.bind (यह)
    fabCapturePhoto? ?setOnClickListener {वैरिडेटपेयर्स ()}
}

मान्यप्रपंच () विधि सत्यापन की देखभाल करती है और उस एप्लिकेशन की अनुमतियों का अनुरोध करती है जो ऐप की आवश्यकता है। यदि अनुमति दी जाती है तो यह एक इरादे के माध्यम से कैमरा ऐप लॉन्च करेगा:

निजी मजेदार सत्यापनकर्ता () {
    Dexter.withActivity (यह)
         .withPermission (Manifest.permission.WRITE_EXTERNAL_STORAGE)
         .withListener (ऑब्जेक्ट: PermissionListener {
                मस्ती को ओवरराइड करें
                  प्रतिक्रिया: PermissionGrantedResponse?) *
                    launchCamera ()
                }

                मस्ती को ओवररिप करें
                   अनुमति: PermissionRequest?
                   टोकन: परमिशनटोकन?) ???
                      AlertDialog.Builder (इस @ MainActivity)
                            .setTitle (
                       R.string.storage_permission_rationale_title)
                            .setMessage (
                       R.string.storage_permition_rationale_message)
                            .setNegativeButton (
                       android.R.string.cancel,
                                    {संवाद, _ ->
                                    dialog.dismiss ()
                                    टोकन? .cancelPermissionRequest ()
                                    })
                            .setPositiveButton (android.R.string.ok,
                                    {संवाद, _ ->
                                  dialog.dismiss ()
                                  टोकन? .continuePermissionRequest ()
                                    })
                            .setOnDismissListener ({
                                 टोकन। cancelPermissionRequest ()})
                            ।प्रदर्शन()
                }

                ओवरराइड मज़ा मज़ा
                    प्रतिक्रिया: PermissionDeniedResponse?) *
                       Snackbar.make (mainContainer !!,
                         R.string.storage_permission_denied_message,
                         Snackbar.LENGTH_LONG)
                       ।प्रदर्शन()
                }
            })
            ।चेक()
}

लॉन्चकैमरा () विधि एक रास्ता बनाएगी जिसे हम अपने इरादे से पारित करने जा रहे हैं और फिर कैमरा ऐप के लिए कॉल करेंगे। इसके अलावा, हमें उस पथ को संग्रहीत करने की आवश्यकता है जिसे हमने बाद में उपयोग के लिए सदस्य चर में बनाया था।

निजी मजेदार लॉन्चकैमरा () {
    वैल वैल्यू = ContentValues ​​(1)
    मान .put (MediaStore.Images.Media.MIME_TYPE, "छवि / jpg")
    वैल फाइलयूरी = सामग्री
            .Insert (MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
                    मान)
    वैल आशय = इरादे (MediaStore.ACTION_IMAGE_CAPTURE)
    अगर (आशय.आसान समाधान) (पैकेज मैनजर)! = अशक्त) {
        mCurrentPhotoPath = fileUri.toString ()
        आशय .putExtra (MediaStore.EXTRA_OUTPUT, fileUri)
        intent.addFlags (Intent.FLAG_GRANT_READ_URI_PERMISSION
                या इरादे। FAGAG_GRANT_WRITE_URI_PERMISSION)
        startActivityForResult (इरादा, TAKE_PHOTO_REQUEST)
    }
}

एक बार जब हम फोटो कैप्चर कर लेते हैं, तो हमें onActivityResult () लागू करने की आवश्यकता होती है, ताकि हम उस तस्वीर को प्रोसेस कर सकें और प्रदर्शित कर सकें जो हमने अभी कैप्चर की है:

मज़ा onActivityResult (अनुरोधकोड: Int, resultCode: Int, में ओवरराइड करें
                              डेटा: इरादे?) (
    अगर (परिणामकोड == गतिविधि .ESULT_OK
           && अनुरोधकोड == TAKE_PHOTO_REQUEST) {
        processCapturedPhoto ()
    } अन्य {
        super.onActivityResult (अनुरोधकोड, परिणामकोड, डेटा)
    }
}

चूंकि मूल फ़ोटो बहुत बड़ी है, इसलिए जब हम इसे अपने ऐप में प्रदर्शित करने का प्रयास करते हैं, तो यह मेमोरी मेमोरी से बाहर हो सकता है। इससे पहले कि हम इसे प्रदर्शित करते हैं, फ्रेस्को छवि को आकार देने का एक सरल तरीका प्रदान करता है।

निजी मज़ेदार प्रक्रिया
    वैल कर्सर = contentResolver.query (Uri.parse (mCurrentPhotoPath),
            एरे (1) {android.provider.MediaStore.Images.ImageColumns.DATA},
            अशक्त, अशक्त, अशक्त)
    cursor.moveToFirst ()
    वैल फोटोपैथ = कर्सर.टगस्ट्रिंग (0)
    cursor.close ()
    वैल फाइल = फाइल (फोटोपाथ)
    वैल यूरी = उरी.फ्रॉमाइल (फाइल)

    वैल ऊंचाई = रिसोर्स.टैमडिमेशनपिक्सलसाइज़ (R.dimen.photo_height)
    वैल चौड़ाई = resource.getDimensionPixelSize (R.dimen.photo_width)

    वैल रिक्वेस्ट = ImageRequestBuilder.newBuilderWithSource (uri)
            .setResizeOptions (ResizeOptions (चौड़ाई, ऊँचाई))
            .build ()
    वैल कंट्रोलर = Fresco.newDraweeControllerBuilder ()
            .setOldController (imgvPhoto? .controller)
            .setImageRequest (अनुरोध)
            .build ()
    imgvPhoto?। नियंत्रक = नियंत्रक
}

यही है, अब हम फ़ोटो खींच सकते हैं और उन्हें बहुत ही सरल तरीके से अपने ऐप के अंदर प्रदर्शित कर सकते हैं।

आप यहाँ नमूना परियोजना के लिए स्रोत कोड पा सकते हैं: https://github.com/bionicwan/capturephoto