Android: Fotózás készítése Kotlin segítségével

A platformon elõzõ elsõ cikkemben elmagyarázom, hogyan készíthet fényképet Androidon a fényképezõgép alkalmazás segítségével, és hogyan kaphatja meg a kapott képet az alkalmazásába. Mindezt Kotlin segítségével programozási nyelvként.

Először új projektet kell létrehoznunk az Android Studio alkalmazásban. Ebben a példában az Android Studio 2.3.3-at használom.

Miután elkészítettük az új projektet, be kell állítanunk a projektet, hogy megkezdhessük a Kotlin-nal való együttműködést. Ezt megteheti a Kotlin weboldal útmutatójának követésével:

Néhány könyvtárat használok a projektben néhány lépés egyszerűsítése érdekében, például kötés megtekintése, képek megjelenítése és engedélykérelmek:

  • A kötés megtekintéséhez a Butterknife-t használtam: http://jakewharton.github.io/butterknife/
  • Engedélykérelemhez mellékeltem a Dextert: https://github.com/Karumi/Dexter
  • A képek megjelenítéséhez a Fresco-t használtam: http://frescolib.org/

A következő lépés az, hogy az Android manifesztumában meghatározzuk azokat az engedélyeket, amelyekre alkalmazásunknak szüksége lesz. Ebben az esetben szükségünk lesz az android.permission.WRITE_EXTERNAL_STORAGE.

Hozzuk létre az alaptevékenységünk elrendezését





    

    

A képernyő így néz ki:

Fő tevékenység

A MainActivity.kt fájlban kattintásszabályozót állítunk be a Lebegő művelet gombra, hogy elindítsuk a kameraalkalmazást, amikor a felhasználó rákattint.

felülírja a szórakoztató onCreate-ot (SaveInstanceState: Bundle?) {
    super.onCreate (savedInstanceState)
    setContentView (R.layout.activity_main)
    ButterKnife.bind (this)
    fabCapturePhoto? .setOnClickListener {validatePermissions ()}
}

Az validatePermission () módszer gondoskodik az alkalmazás által megkövetelt írási engedélyek ellenőrzéséről és kéréséről. Ha az engedélyt megkapják, az egy szándék útján elindítja a kamera alkalmazást:

privát szórakozás validatePermissions () {
    Dexter.withActivity (this)
         .withPermission (Manifest.permission.WRITE_EXTERNAL_STORAGE)
         .withListener (objektum: PermissionListener {
                felülbírálja a szórakozást az onPermissionGranted (
                  válasz: PermissionGrantedResponse?) {
                    launchCamera ()
                }

                felülbírálja a szórakoztató onPermissionRationaleShouldBeShown (
                   engedély: PermissionRequest ?,
                   token: PermissionToken?) {
                      AlertDialog.Builder (ezt @ MainActivity)
                            .setTitle (
                       R.string.storage_permission_rationale_title)
                            .setMessage (
                       R.string.storage_permition_rationale_message)
                            .setNegativeButton (
                       android.R.string.cancel,
                                    {párbeszédpanel, _ ->
                                    dialog.dismiss ()
                                    token? .cancelPermissionRequest ()
                                    })
                            .setPositiveButton (android.R.string.ok,
                                    {párbeszédpanel, _ ->
                                  dialog.dismiss ()
                                  token? .continuePermissionRequest ()
                                    })
                            .setOnDismissListener ({
                                 token? .cancelPermissionRequest ()})
                            .előadás()
                }

                felülbírálja a szórakozást az onPermissionDenied (
                    válasz: PermissionDeniedResponse?) {
                       Snackbar.make (mainContainer !!,
                         R.string.storage_permission_denied_message,
                         Snackbar.LENGTH_LONG)
                       .előadás()
                }
            })
            .jelölje be()
}

Az launchCamera () módszer létrehoz egy utat, amelyet át akarunk adni szándékunkhoz, majd felhívjuk a kamera alkalmazást. Ezenkívül a létrehozott elérési utat egy tagváltozóban kell tárolni későbbi felhasználás céljából.

privát szórakoztató elindításCamera () {
    val értékek = ContentValues ​​(1)
    értékek.menet (MediaStore.Images.Media.MIME_TYPE, "image / jpg")
    val fileUri = contentResolver
            .insert (MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
                    értékek)
    val intent = Szándék (MediaStore.ACTION_IMAGE_CAPTURE)
    if (intent.resolveActivity (packageManager)! = null) {
        mCurrentPhotoPath = fileUri.toString ()
        intent.putExtra (MediaStore.EXTRA_OUTPUT, fileUri)
        intent.addFlags (Intent.FLAG_GRANT_READ_URI_PERMISSION
                vagy Intent.FLAG_GRANT_WRITE_URI_PERMISSION)
        startActivityForResult (szándék, TAKE_PHOTO_REQUEST)
    }
}

Miután elfoglalták a fényképet, telepítenünk kell az onActivityResult () alkalmazást, így feldolgozhatjuk és megjeleníthetjük az éppen rögzített fényképet:

felülírja a móka onActivityResult (requestCode: Int, resultCode: Int,
                              adatok: szándék?) {
    if (resultCode == Tevékenység.RESULT_OK
           && requestCode == TAKE_PHOTO_REQUEST) {
        processCapturedPhoto ()
    } más {
        super.onActivityResult (requestCode, resultCode, data)
    }
}

Mivel az eredeti fénykép túl nagy, memóriahiányhoz vezethet, amikor megpróbáljuk megjeleníteni azt az alkalmazásunkban. A Fresco egyszerű módot kínál a kép átméretezésére, mielőtt megjelenítjük.

privát szórakoztató folyamatCapturedPhoto () {
    val kurzor = contentResolver.query (Uri.parse (mCurrentPhotoPath),
            Tömb (1) {android.provider.MediaStore.Images.ImageColumns.DATA},
            null, null, null)
    cursor.moveToFirst ()
    val photoPath = cursor.getString (0)
    cursor.close ()
    val fájl = Fájl (photoPath)
    val uri = Uri.fromFile (fájl)

    val magasság = resources.getDimensionPixelSize (R.dimen.photo_height)
    val width = resources.getDimensionPixelSize (R.dimen.photo_width)

    val request = ImageRequestBuilder.newBuilderWithSource (uri)
            .setResizeOptions (ResizeOptions (szélesség, magasság))
            .épít()
    val controller = Fresco.newDraweeControllerBuilder ()
            .setOldController (imgvPhoto? .controller)
            .setImageRequest (kérésre)
            .épít()
    imgvPhoto? .controller = vezérlő
}

Ennyi, most fotókat készíthetünk, és nagyon egyszerű módon megjeleníthetjük őket alkalmazásunkban.

A mintaprojekt forráskódját itt találja: https://github.com/bionicwan/capturephoto