Android2_Lesson5

app/src/main/java/com/uzlov/moviefind/fragments/FilmFragment.kt

@@ -5,32 +5,37 @@ import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import androidx.fragment.app.Fragment
+import androidx.lifecycle.ViewModelProvider
 import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.RecyclerView
 import com.uzlov.moviefind.databinding.FragmentFilmBinding
-import com.uzlov.moviefind.model.TestFilm
 import com.uzlov.moviefind.ui.ActorFilmsAdapter
 import com.uzlov.moviefind.ui.MyItemDecorator
+import com.uzlov.moviefind.viewmodels.FilmsViewModel
 
 class FilmFragment : Fragment() {
     private var _viewBinding: FragmentFilmBinding?=null
     private val viewBinding get() = _viewBinding!!
-    private lateinit var film : TestFilm
+    private val viewModel: FilmsViewModel by lazy {
+        ViewModelProvider(this).get(FilmsViewModel::class.java)
+    }
+    private var id_film  = 0
 
     companion object {
-        fun newInstance(testFilm: TestFilm): FilmFragment {
+        fun newInstance(id: Int): FilmFragment {
             val data = Bundle().apply {
-                putParcelable("film_key", testFilm)
+                putInt("film_key", id)
             }
             return FilmFragment().apply { arguments = data }
         }
     }
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-        film = arguments?.getParcelable("film_key") ?: TestFilm()
+        id_film = arguments?.getInt("film_key") ?: 0
     }
 
+
     override fun onCreateView(
         inflater: LayoutInflater,
         container: ViewGroup?,
@@ -42,24 +47,27 @@ class FilmFragment : Fragment() {
 
     override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
         super.onViewCreated(view, savedInstanceState)
-        with(viewBinding) {
-            titleTv.text = film.name
-            ratingFilm.rating = film.rating.toFloat()
-            descriptionTV.text = film.description
-            genreFilmTv.text = film.genre
-            studioFilm.text = film.studio
-            yearFilmTv.text = film.year
 
-            recyclerViewActor.apply {
-                adapter = ActorFilmsAdapter()
-                layoutManager = LinearLayoutManager(requireContext(), RecyclerView.HORIZONTAL, false)
-                addItemDecoration(MyItemDecorator(1), RecyclerView.HORIZONTAL)
-            }
+        viewModel.getFilmById(id_film).observe(viewLifecycleOwner, {
+            with(viewBinding) {
+                titleTv.text = it.title
+                ratingFilm.rating = it.vote_average.div(2).toFloat()
+                descriptionTV.text = it.overview
+                genreFilmTv.text = it.genres.joinToString(", ")
+                studioFilm.text = it.production_companies[0].name
+                yearFilmTv.text = it.release_date
 
-            backButton.setOnClickListener {
-                parentFragmentManager.popBackStack()
+                recyclerViewActor.apply {
+                    adapter = ActorFilmsAdapter()
+                    layoutManager = LinearLayoutManager(requireContext(), RecyclerView.HORIZONTAL, false)
+                    addItemDecoration(MyItemDecorator(1), RecyclerView.HORIZONTAL)
+                }
+
+                backButton.setOnClickListener {
+                    parentFragmentManager.popBackStack()
+                }
             }
-        }
+        })
     }
 
     override fun onDestroyView() {

app/src/main/java/com/uzlov/moviefind/fragments/HomeFragment.kt

@@ -5,25 +5,62 @@ import androidx.fragment.app.Fragment
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
-import android.widget.Button
-import android.widget.Toast
-import com.uzlov.moviefind.R
+import androidx.lifecycle.ViewModelProvider
+import androidx.recyclerview.widget.LinearLayoutManager
 
-class HomeFragment : Fragment() {
 
-    companion object{
-        fun newInstance() : HomeFragment {
-            return HomeFragment()
-        }
+import com.uzlov.moviefind.R
+import com.uzlov.moviefind.databinding.FragmentHomeBinding
+import com.uzlov.moviefind.interfaces.IOnClickListenerAdapter
+import com.uzlov.moviefind.ui.FilmAdapter
+import com.uzlov.moviefind.viewmodels.FilmsViewModel
+
+class HomeFragment : Fragment() , IOnClickListenerAdapter{
+    private var _viewBinding: FragmentHomeBinding ?= null
+    private val viewBinding get() = _viewBinding!!
+    private val viewModel: FilmsViewModel by lazy {
+        ViewModelProvider(this).get(FilmsViewModel::class.java)
     }
+
     override fun onCreateView(
             inflater: LayoutInflater, container: ViewGroup?,
             savedInstanceState: Bundle?
-    ): View? {
-        return inflater.inflate(R.layout.fragment_home, container, false)
+    ): View {
+        _viewBinding = FragmentHomeBinding.inflate(layoutInflater, container, false)
+        return viewBinding.root
     }
 
     override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
         super.onViewCreated(view, savedInstanceState)
+        loadData()
+    }
+
+    private fun loadData(){
+        val adapterTopFilms = FilmAdapter(this)
+        viewModel.getTopRatedFilms().observe(viewLifecycleOwner, {
+            adapterTopFilms.setFilms(it.results)
+            viewBinding.recommendRV.apply {
+                adapter = adapterTopFilms
+                layoutManager = LinearLayoutManager(context, LinearLayoutManager.HORIZONTAL, false)
+            }
+        })
+
+        val adapterPopularFilms = FilmAdapter(this)
+        viewModel.getPopularFilms().observe(viewLifecycleOwner, {
+            viewBinding.popularRV.apply {
+                adapterPopularFilms.setFilms(it.results)
+                adapter = adapterPopularFilms
+                layoutManager = LinearLayoutManager(context, LinearLayoutManager.HORIZONTAL, false)
+            }
+        })
+    }
+
+    override fun onClick(position: Int, id: Int) {
+        parentFragmentManager.beginTransaction().run {
+            hide(this@HomeFragment)
+            add(R.id.fragment_container, FilmFragment.newInstance(id))
+            addToBackStack(null)
+            commit()
+        }
     }
 }

app/src/main/java/com/uzlov/moviefind/interfaces/Loadable.kt

@@ -1,6 +1,12 @@
 package com.uzlov.moviefind.interfaces
 
+import androidx.lifecycle.MutableLiveData
+import com.uzlov.moviefind.model.Film
+import com.uzlov.moviefind.model.PopularFilms
+
 @FunctionalInterface
-public interface Loadable<T> {
-    fun loadPopular(films: (List<T>) -> Unit)
+public interface Loadable {
+    fun loadPopular() : MutableLiveData<PopularFilms>
+    fun loadFilmById(id: Int) : MutableLiveData<Film>
+    fun loadTopRatedFilms(): MutableLiveData<PopularFilms>
 }

app/src/main/java/com/uzlov/moviefind/model/Film.kt

@@ -26,4 +26,11 @@ data class Film(
     val video: Boolean,
     val vote_average: Double,
     val vote_count: Int
-)
+) {
+    fun getImage50() : String {
+        return "https://image.tmdb.org/t/p/w500$poster_path"
+    }
+    fun getImageOriginal() : String {
+        return "https://image.tmdb.org/t/p/original$poster_path"
+    }
+}

app/src/main/java/com/uzlov/moviefind/model/Result.kt

@@ -15,4 +15,11 @@ data class Result(
     val video: Boolean,
     val vote_average: Double,
     val vote_count: Int
-)
+) {
+    fun getImage50() : String {
+        return "https://image.tmdb.org/t/p/w500$poster_path"
+    }
+    fun getImageOriginal() : String {
+        return "https://image.tmdb.org/t/p/original$poster_path"
+    }
+}

app/src/main/java/com/uzlov/moviefind/repository/RepositoryPopularImpl.kt

@@ -1,11 +1,134 @@
 package com.uzlov.moviefind.repository
 
+import android.os.Build
+import androidx.lifecycle.MutableLiveData
+import com.google.gson.Gson
+import com.uzlov.moviefind.interfaces.Constants
 import com.uzlov.moviefind.interfaces.Loadable
+import com.uzlov.moviefind.model.Film
 import com.uzlov.moviefind.model.PopularFilms
+import java.io.BufferedReader
+import java.io.IOException
+import java.io.InputStreamReader
+import java.net.MalformedURLException
+import java.net.URL
+import java.util.stream.Collectors
+import javax.net.ssl.HttpsURLConnection
 
-object RepositoryPopularImpl : Loadable<PopularFilms> {
 
-    override fun loadPopular(films: (List<PopularFilms>) -> Unit) {
+object RepositoryPopularImpl : Loadable {
 
+    override fun loadPopular() : MutableLiveData<PopularFilms>{
+        val uriPopularFilms = URL("https://api.themoviedb.org/3/movie/popular?api_key=${Constants.API_KEY}&language=ru-RU")
+        val responseLiveData: MutableLiveData<PopularFilms> = MutableLiveData()
+
+
+        try {
+            Thread {
+                lateinit var urlConnection: HttpsURLConnection
+                try {
+                    urlConnection = (uriPopularFilms.openConnection() as HttpsURLConnection).apply {
+                        requestMethod = "GET"
+                        readTimeout = 10_000
+                    }
+                    val bufferedReader =
+                        BufferedReader(InputStreamReader(urlConnection.inputStream))
+
+                    val popularFilms =
+                        Gson().fromJson(bufferedReader.getLines(), PopularFilms::class.java)
+                    responseLiveData.postValue(popularFilms)
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                } finally {
+                    urlConnection.disconnect()
+                }
+            }.start()
+        } catch (e: MalformedURLException){
+            e.printStackTrace()
+        }
+        return responseLiveData
+    }
+
+    override fun loadFilmById(id: Int): MutableLiveData<Film> {
+        val uriDetailFilm = URL("https://api.themoviedb.org/3/movie/$id?api_key=${Constants.API_KEY}&language=ru-RU")
+        val responseLiveData: MutableLiveData<Film> = MutableLiveData()
+
+        try {
+            Thread {
+                lateinit var urlConnection: HttpsURLConnection
+                try {
+                    urlConnection = (uriDetailFilm.openConnection() as HttpsURLConnection).apply {
+                        requestMethod = "GET"
+                        readTimeout = 10_000
+                    }
+                    val bufferedReader =
+                        BufferedReader(InputStreamReader(urlConnection.inputStream))
+
+                    val film =
+                        Gson().fromJson(bufferedReader.getLines(), Film::class.java)
+                    responseLiveData.postValue(film)
+
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                } finally {
+                    urlConnection.disconnect()
+                }
+            }.start()
+        } catch (e: MalformedURLException){
+            e.printStackTrace()
+        }
+        return responseLiveData
+    }
+
+
+    override fun loadTopRatedFilms(): MutableLiveData<PopularFilms> {
+        val uriDetailFilm = URL("https://api.themoviedb.org/3/movie/top_rated?api_key=${Constants.API_KEY}&language=ru-RU")
+        val responseLiveData: MutableLiveData<PopularFilms> = MutableLiveData()
+
+        try {
+            Thread {
+                lateinit var urlConnection: HttpsURLConnection
+                try {
+                    urlConnection = (uriDetailFilm.openConnection() as HttpsURLConnection).apply {
+                        requestMethod = "GET"
+                        readTimeout = 10_000
+                    }
+                    val bufferedReader =
+                        BufferedReader(InputStreamReader(urlConnection.inputStream))
+
+                    val film =
+                        Gson().fromJson(bufferedReader.getLines(), PopularFilms::class.java)
+                    responseLiveData.postValue(film)
+
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                } finally {
+                    urlConnection.disconnect()
+                }
+            }.start()
+        } catch (e: MalformedURLException){
+            e.printStackTrace()
+        }
+        return responseLiveData
+    }
+
+
+
+
+    private fun BufferedReader.getLines() : String {
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            lines().collect(Collectors.joining("\n"))
+        } else {
+            val builder = StringBuilder()
+            try {
+                var line: String?
+                while (readLine().also { line = it } != null) {
+                    builder.append(line).append("\n")
+                }
+            } catch (e: IOException) {
+                e.printStackTrace()
+            }
+            return builder.toString()
+        }
     }
 }

app/src/main/java/com/uzlov/moviefind/ui/FilmAdapter.kt

@@ -0,0 +1,47 @@
+package com.uzlov.moviefind.ui
+
+import android.view.LayoutInflater
+import android.view.ViewGroup
+import androidx.recyclerview.widget.RecyclerView
+import com.bumptech.glide.Glide
+import com.uzlov.moviefind.databinding.ItemFilmBinding
+import com.uzlov.moviefind.interfaces.IOnClickListenerAdapter
+import com.uzlov.moviefind.model.Result
+
+class FilmAdapter(private val onClick: IOnClickListenerAdapter) :
+    RecyclerView.Adapter<FilmAdapter.FilmsHolder>() {
+    private val mListFilms: MutableList<Result> = mutableListOf()
+
+    fun setFilms(films: List<Result>) {
+        mListFilms.clear()
+        mListFilms.addAll(films)
+    }
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): FilmsHolder {
+        val binding = ItemFilmBinding.inflate(LayoutInflater.from(parent.context), parent, false)
+        return FilmsHolder(binding)
+    }
+
+    override fun onBindViewHolder(holder: FilmsHolder, position: Int) {
+        holder.onBind(mListFilms[position])
+    }
+
+    override fun getItemCount(): Int = mListFilms.size
+
+    inner class FilmsHolder(private val binding: ItemFilmBinding) :
+        RecyclerView.ViewHolder(binding.root) {
+        fun onBind(film: Result) {
+            with(binding) {
+                Glide
+                    .with(root.context)
+                    .load(film.getImage50())
+                    .into(imageFilm)
+                titleFilmTV.text = film.title
+                ratingFilm.rating = film.vote_average.toFloat().div(2)
+                root.setOnClickListener {
+                    onClick.onClick(adapterPosition, film.id)
+                }
+            }
+        }
+    }
+}