API tools faq
paste
MLDZ

igrodil room name

MLDZ
May 25th, 2020
83
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Kotlin 38.11 KB | None | 0 0
raw download clone embed print report
  1. package com.mldz.igrodil.db
  2.  
  3. import android.content.Intent
  4. import android.provider.Settings
  5. import androidx.localbroadcastmanager.content.LocalBroadcastManager
  6. import com.google.firebase.database.*
  7. import com.mldz.igrodil.App
  8. import com.mldz.igrodil.R
  9. import com.mldz.igrodil.api.models.GameDataModel
  10. import com.mldz.igrodil.api.models.RoomModelItem
  11. import com.mldz.igrodil.managers.IgrodilManager
  12. import com.mldz.igrodil.ui.fragments.FinishGameFragment
  13. import io.reactivex.Observable
  14. import timber.log.Timber
  15.  
  16. object RealtimeDatabase {
  17.     private var database: FirebaseDatabase = FirebaseDatabase.getInstance()
  18.     private lateinit var roomRef: DatabaseReference
  19.     private var roomsRef: DatabaseReference
  20.     private lateinit var playerRef: DatabaseReference
  21.     private val gameRef: DatabaseReference
  22.     private var playerName = App.getPreferences().getUsername()
  23.     private var room = ""
  24.     private var roomList = ArrayList<RoomModelItem>()
  25.     val fullName: String
  26.  
  27.     private const val gameStatus = "gameStatus"
  28.  
  29.     const val WAIT_PLAYERS = 1
  30.     const val GAME_RUN = 2
  31.     const val GAME_FINISH = 3
  32.     const val IN_GAME = 11
  33.     const val PLAYER_FINISH_GAME = 12
  34.  
  35.     init {
  36.         gameRef = database.reference.child("games")
  37.         roomsRef = database.reference.child("rooms")
  38.         fullName = initName()
  39.     }
  40.  
  41.     private fun initName(): String {
  42.         val fName = App.getPreferences().getUserFirstName()
  43.         val lName = App.getPreferences().getUserLastName()
  44.         return if (App.getPreferences().isAuth()) {
  45.             if (lName.isNotEmpty())
  46.                 "$fName $lName"
  47.             else
  48.                 fName
  49.         } else {
  50.             val id = Settings.Secure.getString(
  51.                 IgrodilManager.getContext().contentResolver,
  52.                 Settings.Secure.ANDROID_ID
  53.             )
  54.             "$fName ${id.substring(id.length - 4)}"
  55.         }
  56.     }
  57.  
  58.     fun getRooms(): Observable<List<RoomModelItem>> {
  59.         return Observable.create {
  60.             roomsRef.addValueEventListener(object : ValueEventListener {
  61.                 override fun onCancelled(p0: DatabaseError) {
  62.                     it.onError(Throwable(p0.message))
  63.                 }
  64.  
  65.                 override fun onDataChange(p0: DataSnapshot) {
  66.                     // update room list
  67.                     roomList.clear()
  68.                     val rooms = p0.children
  69.                     for (room in rooms) {
  70.                         val level = (room.child("level").value as Long).toInt()
  71.                         var size = -1
  72.                         for (c in room.children) {
  73.                             size++
  74.                         }
  75.                         roomList.add(RoomModelItem(room.key!!, level, size))
  76.                     }
  77.                     it.onNext(roomList)
  78.                 }
  79.             })
  80.         }
  81.     }
  82.  
  83.     fun createRoom(name: String, level: Int): Observable<HashMap<Int, String>> {
  84.         // create room and add yourself as player1
  85.         return Observable.create {
  86.             room = name
  87.             roomRef = database.getReference("rooms/$room/$playerName")
  88.             roomsRef.child(room).child("level").setValue(level)
  89.             roomRef.child("name").setValue(fullName)
  90.             roomRef.child("isCreator").setValue(1)
  91.             roomsRef.child(room).child("creator").setValue(playerName)
  92.             val res = hashMapOf(0 to playerName, 1 to room)
  93.             it.onNext(res)
  94.         }
  95.     }
  96.  
  97.     fun initPlayer(): Observable<Boolean> {
  98.         // logging player in
  99.         playerRef = database.getReference("players/$playerName")
  100.         val res = addPlayerEventListener()
  101.         playerRef.setValue("")
  102.         return res
  103.     }
  104.  
  105.     private fun addPlayerEventListener(): Observable<Boolean> {
  106.         // read from database players
  107.         return Observable.create {
  108.             playerRef.addValueEventListener(object : ValueEventListener {
  109.                 override fun onCancelled(p0: DatabaseError) {
  110.                     Timber.d(p0.message)
  111.                     it.onError(Throwable(p0.message))
  112.                 }
  113.  
  114.                 override fun onDataChange(p0: DataSnapshot) {
  115.                     // success player
  116.                     it.onNext(true)
  117.                 }
  118.             })
  119.         }
  120.     }
  121.  
  122.     fun loginRoom(roomName: String): Observable<HashMap<Int, String>> {
  123.         //join in existing room and add yourself as player (playerName)
  124.         return Observable.create {
  125.             roomsRef.child(roomName).addListenerForSingleValueEvent(object : ValueEventListener {
  126.                 override fun onCancelled(p0: DatabaseError) {
  127.  
  128.                 }
  129.  
  130.                 override fun onDataChange(p0: DataSnapshot) {
  131.                     var size = -1
  132.                     val users = p0.children
  133.                     for (user in users)
  134.                         size++
  135.                     if (size < 5) {
  136.                         roomRef = roomsRef.child(roomName)
  137.                         if (!App.getPreferences().isAuth())
  138.                             playerName = Settings.Secure.getString(IgrodilManager.getContext().contentResolver, Settings.Secure.ANDROID_ID)
  139.                         roomsRef.child(roomName).child(playerName).child("name").setValue(fullName)
  140.                         room = roomName
  141.                         it.onNext(hashMapOf(0 to "", 1 to room))
  142.                     }
  143.                     else
  144.                         it.onError(Throwable(IgrodilManager.getContext().getString(R.string.no_place_in_room)))
  145.                 }
  146.             })
  147.  
  148.         }
  149.     }
  150.  
  151.     fun getUsers(roomName: String): Observable<ArrayList<String>> {
  152.         return Observable.create {
  153.             val users = ArrayList<String>()
  154.             database.reference.child("rooms").child(roomName).addChildEventListener(object : ChildEventListener {
  155.                 override fun onCancelled(p0: DatabaseError) {
  156.  
  157.                 }
  158.  
  159.                 override fun onChildMoved(p0: DataSnapshot, p1: String?) {
  160.  
  161.                 }
  162.  
  163.                 override fun onChildChanged(p0: DataSnapshot, p1: String?) {
  164.  
  165.                 }
  166.  
  167.                 override fun onChildAdded(p0: DataSnapshot, p1: String?) {
  168.                     if (p0.key != "level" && p0.key != "creator")
  169.                         users.add((p0.value as HashMap<*, *>)["name"] as String)
  170.                     it.onNext(users)
  171.                 }
  172.  
  173.                 override fun onChildRemoved(p0: DataSnapshot) {
  174.                     try {
  175.                         users.remove((p0.value as HashMap<*, *>)["name"] as String)
  176.                     } catch (e: Exception) {
  177.  
  178.                     }
  179.                     if (users.size < 1) {
  180.                         closeRoom(roomName)
  181.                         gameRef.child(roomName).removeValue()
  182.                     }
  183.                     else
  184.                         it.onNext(users)
  185.                 }
  186.  
  187.             })
  188.         }
  189.     }
  190.  
  191.     fun leaveRoom() {
  192.         if (room.isNotEmpty()) {
  193.             database.reference.child("rooms").child(room).child(playerName).removeValue()
  194.         }
  195.     }
  196.  
  197.     fun closeRoom(roomName: String) {
  198.         database.reference.child("rooms").child(roomName).removeValue()
  199.     }
  200.  
  201.     fun addGameEventListener(roomName: String, video: GameDataModel): Observable<GameDataModel> {
  202.         var statusGame = WAIT_PLAYERS
  203.         return Observable.create {
  204.             if (roomName.isNotEmpty()) {
  205.                 val isCreator = roomName == App.getPreferences().getUsername()
  206.                 if (isCreator) {
  207.                     val key = gameRef.child(roomName).push().key
  208.                     if (key != null) {
  209.                         val childUpdates = HashMap<String, Any>()
  210.                         val videoMap = video.toMap()
  211.                         videoMap[gameStatus] = WAIT_PLAYERS
  212.                         videoMap["winner"] = ""
  213.                         childUpdates["games/$roomName"] = videoMap
  214.                         database.reference.updateChildren(childUpdates)
  215.                     }
  216.                 }
  217.                 gameRef.child(roomName).addValueEventListener(object : ValueEventListener {
  218.                     override fun onCancelled(p0: DatabaseError) {
  219.                         it.onError(Throwable())
  220.                     }
  221.  
  222.                     override fun onDataChange(p0: DataSnapshot) {
  223.                         try {
  224.                             if (p0.value != null) {
  225.                                 val result = p0.value as HashMap<*, *>
  226.                                 when {
  227.                                     result["winner"].toString().isNotEmpty() -> {
  228.                                         if (statusGame == GAME_RUN) {
  229.                                             it.onNext(
  230.                                                 GameDataModel(
  231.                                                     result["id"].toString().toInt(),
  232.                                                     result["thumbnail"].toString(),
  233.                                                     result["url"].toString(),
  234.                                                     result["word"].toString(),
  235.                                                     result["winner"].toString()
  236.                                                 )
  237.                                             )
  238.                                         }
  239.                                         statusGame = GAME_FINISH
  240.                                     }
  241.                                     result[gameStatus].toString().toInt() == GAME_RUN -> {
  242.                                         it.onNext(
  243.                                             GameDataModel(
  244.                                                 result["id"].toString().toInt(),
  245.                                                 result["thumbnail"].toString(),
  246.                                                 result["url"].toString(),
  247.                                                 result["word"].toString(),
  248.                                                 null
  249.                                             )
  250.                                         )
  251.                                         setPlayerStatus(roomName, IN_GAME)
  252.                                         statusGame = GAME_RUN
  253.                                     }
  254.                                     result[gameStatus].toString().toInt() == WAIT_PLAYERS ->
  255.                                         LocalBroadcastManager.getInstance(IgrodilManager.getContext()).sendBroadcast(
  256.                                             Intent(FinishGameFragment.START_NEW_GAME_ROOM)
  257.                                         )
  258.                                 }
  259.                             }
  260.                         } catch (e: Exception) {
  261.                             it.onError(e)
  262.                         }
  263.                     }
  264.                 })
  265.             }
  266.         }
  267.     }
  268.  
  269.     fun setGameRun(roomName: String) {
  270.         if (roomName.isNotEmpty())
  271.             gameRef.child(roomName).child(gameStatus).setValue(GAME_RUN)
  272.     }
  273.  
  274.     fun startNewGame(roomName: String) {
  275.         gameRef.child(roomName).child(gameStatus).setValue(WAIT_PLAYERS)
  276.     }
  277.  
  278.     fun onGameWin(roomName: String) {
  279.         if (roomName.isNotEmpty()) {
  280.             gameRef.child(roomName).child("winner").setValue(fullName)
  281.             gameRef.child(roomName).child(gameStatus).setValue(GAME_FINISH)
  282.         }
  283.     }
  284.  
  285.     fun setPlayerStatus(roomName: String, status: Int) {
  286.         if (roomName.isNotEmpty())
  287.             roomsRef.child(roomName).child(playerName).child("status").setValue(status)
  288.     }
  289.  
  290.     fun getRoomListener(): Observable<Boolean> {
  291.         return Observable.create {
  292.             roomsRef.child(room).addValueEventListener(object : ValueEventListener {
  293.                 override fun onCancelled(p0: DatabaseError) {
  294.  
  295.                 }
  296.  
  297.                 override fun onDataChange(p0: DataSnapshot) {
  298.                     val players = p0.children
  299.                     var allReady = true
  300.                     for (player in players) {
  301.                         val data = player.child("status").value
  302.                         if (data != null) {
  303.                             val status = (data as Long).toInt()
  304.                             if (status != PLAYER_FINISH_GAME) {
  305.                                 allReady = false
  306.                                 break
  307.                             }
  308.                         }
  309.                     }
  310.                     it.onNext(allReady)
  311.                 }
  312.             })
  313.         }
  314.     }
  315.  
  316.     fun getCreatorOfRoom() {
  317.         if (room.isNotEmpty()) {
  318. //            return roomsRef.child(room).child("creator").addListenerForSingleValueEvent(object : ValueEventListener {
  319. //                override fun onCancelled(p0: DatabaseError) {
  320. //                    TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
  321. //                }
  322. //
  323. //                override fun onDataChange(p0: DataSnapshot) {
  324. //                    TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
  325. //                }
  326. //            })
  327.         }
  328.     }
  329. }
  330.  
  331.  
  332. package com.mldz.igrodil.mvp.views
  333.  
  334. import com.mldz.igrodil.api.models.RoomModelItem
  335.  
  336. interface RoomFragmentView: ProgressBarView, NoInternetView {
  337.     fun showLevelDialog()
  338.     fun setRooms(rooms: List<RoomModelItem>)
  339.     fun startGame(level: Int, room: HashMap<Int, String>)
  340.     fun showNoRooms()
  341.     fun hideNoRooms()
  342.     fun showSnackBar(message: String)
  343.     fun disableCreateRoomButton()
  344. }
  345.  
  346.  
  347. package com.mldz.igrodil.mvp.models
  348.  
  349. import com.mldz.igrodil.api.models.RoomModelItem
  350. import com.mldz.igrodil.db.RealtimeDatabase
  351. import io.reactivex.Observable
  352.  
  353. class RoomFragmentModel {
  354.     fun getRooms(): Observable<List<RoomModelItem>> {
  355.         return RealtimeDatabase.getRooms()
  356.     }
  357.  
  358.     fun createRoom(name: String, level: Int): Observable<HashMap<Int, String>> {
  359.         return RealtimeDatabase.createRoom(name, level)
  360.     }
  361.  
  362.     fun initPlayer(): Observable<Boolean> {
  363.         return RealtimeDatabase.initPlayer()
  364.     }
  365.  
  366.     fun loginRoom(roomName: String): Observable<HashMap<Int, String>> {
  367.         return RealtimeDatabase.loginRoom(roomName)
  368.     }
  369. }
  370.  
  371.  
  372. package com.mldz.igrodil.mvp.presenters
  373.  
  374. import com.mldz.igrodil.App
  375. import com.mldz.igrodil.api.models.FinishGameModel
  376. import com.mldz.igrodil.api.models.GameDataModel
  377. import com.mldz.igrodil.mvp.models.ProcessGameFragmentModel
  378. import com.mldz.igrodil.mvp.views.ProcessGameFragmentView
  379. import com.mldz.igrodil.ui.activities.GameActivity
  380. import com.mldz.igrodil.utils.Define
  381. import com.mldz.igrodil.utils.NetworkUtils
  382. import io.reactivex.android.schedulers.AndroidSchedulers
  383. import io.reactivex.disposables.CompositeDisposable
  384. import io.reactivex.schedulers.Schedulers
  385. import timber.log.Timber
  386. import java.util.concurrent.TimeUnit
  387. import kotlin.random.Random
  388.  
  389. class ProcessGameFragmentPresenter(private val view: ProcessGameFragmentView): VideoPresenter() {
  390.     private val model: ProcessGameFragmentModel = ProcessGameFragmentModel()
  391.     private val disposable = CompositeDisposable()
  392.     private lateinit var word: String
  393.     private lateinit var knownWord: CharArray
  394.     private lateinit var nonKnownWord: CharArray
  395.     private var videoId: Int = -1
  396.     private var lettersNumber: ArrayList<Int> = ArrayList()
  397.     private lateinit var roomName: String
  398.     private lateinit var creator: String
  399.     private var isRoom = false
  400.     private var myWin = false
  401.  
  402.     fun onCreate(type: Int, room: String, level: Int, creator: String) {
  403.         roomName = room
  404.         this.creator = creator
  405.         isRoom = type == GameActivity.GAME_TYPE_MULTI
  406.         prepareGame(isRoom, level)
  407.     }
  408.  
  409.     private fun getUsers() {
  410.         if (roomName.isNotEmpty()) {
  411.             disposable.add(model.getUsers(roomName)
  412.                 .subscribeOn(Schedulers.io())
  413.                 .observeOn(AndroidSchedulers.mainThread())
  414.                 .subscribe {
  415.                     when {
  416.                         it.size > 0 -> view.updateUsers(it)
  417.                         else -> view.onCloseRoom()
  418.                     }
  419.                 })
  420.         }
  421.     }
  422.  
  423.     private fun prepareGame(isRoom: Boolean, level: Int) {
  424.         if (NetworkUtils.isOnline()) {
  425.             view.enableProgressBar(true)
  426.             disposable.add(model.getWord(level)
  427.                 .subscribeOn(Schedulers.io())
  428.                 .observeOn(AndroidSchedulers.mainThread())
  429.                 .subscribe({
  430.                     if (it.isSuccessful && it.body() != null) {
  431.                         when (isRoom) {
  432.                             false -> startGame(it.body()!!)
  433.                             true -> {
  434.                                 view.enableProgressBar(false)
  435.                                 if (roomName.isNotEmpty()) {
  436.                                     val isCreator = creator == App.getPreferences().getUsername()
  437. //                                    val isCreator = model.isCreator()
  438.                                     view.showWaitPlayers(isCreator)
  439.                                     getUsers()
  440.                                     prepareGameObservable(it.body()!!)
  441.                                 }
  442.                             }
  443.                         }
  444.                     }
  445.                 }, {
  446.                     Timber.d(it)
  447.                 }))
  448.         } else {
  449.             view.showNoInternet()
  450.         }
  451.     }
  452.  
  453.     private fun prepareGameObservable(video: GameDataModel) {
  454.         disposable.add(model.addGameEventListener(roomName, video)
  455.             .subscribeOn(Schedulers.io())
  456.             .observeOn(AndroidSchedulers.mainThread())
  457.             .subscribe({
  458.                 if (it.winner != null && !myWin) {
  459.                     view.finish(FinishGameModel(false, it.id, it.word, it.winner, 0, 0, isRoom, roomName))
  460.                 }
  461.                 else
  462.                     startGame(it)
  463.             }, {
  464.  
  465.             }, {
  466.  
  467.             }))
  468.     }
  469.  
  470.     private fun startGame(it: GameDataModel) {
  471.         view.enableProgressBar(false)
  472.         videoId = it.id
  473.         view.setVideo(it.url)
  474.         createWords(it.word)
  475.         if (!model.isEnoughScores()) {
  476.             view.disableAddLetterBtn()
  477.             view.disableAddMinuteBtn()
  478.         }
  479.     }
  480.  
  481.     fun onRoomGameStart() {
  482.         if (roomName.isNotEmpty()) {
  483.             view.hideWaitPlayers()
  484.             model.setStartGame(roomName)
  485.         }
  486.     }
  487.  
  488.     private fun createWords(word: String) {
  489.         this.word = word
  490.         knownWord = word.toCharArray()
  491.         nonKnownWord = CharArray(knownWord.size)
  492.         for ((i, l) in knownWord.withIndex()) {
  493.             lettersNumber.add(i)
  494.             nonKnownWord[i] = '_'
  495.         }
  496.     }
  497.  
  498.     fun addMinute() {
  499.         if (model.isEnoughScores()) {
  500.             if (model.changeScores(Define.ADD_MINUTE_SCORES) == 0) {
  501.                 view.disableAddLetterBtn()
  502.                 view.disableAddMinuteBtn()
  503.             }
  504.             view.addMinute()
  505.             view.updatePoints(model.getPointsValue().toString())
  506.         } else {
  507.             view.disableAddLetterBtn()
  508.             view.disableAddMinuteBtn()
  509.         }
  510.     }
  511.  
  512.     fun addLetter() {
  513.         if (model.isEnoughScores() && lettersNumber.size > 0) {
  514.             if (model.changeScores(Define.ADD_LETTER_SCORES) == 0) {
  515.                 view.disableAddLetterBtn()
  516.                 view.disableAddMinuteBtn()
  517.             }
  518.             var random = 0
  519.             if (lettersNumber.size > 2)
  520.                 random = Random.nextInt(0, lettersNumber.size - 1)
  521.             val pos = lettersNumber[random]
  522.             lettersNumber.removeAt(random)
  523.             if (lettersNumber.size == 0) {
  524.                 view.disableAddLetterBtn()
  525.             }
  526.             val letter = knownWord[pos]
  527.             nonKnownWord[pos] = letter
  528.             view.showLetter(nonKnownWord.joinToString(""))
  529.             view.updatePoints(model.getPointsValue().toString())
  530.         } else {
  531.             view.disableAddLetterBtn()
  532.             view.disableAddMinuteBtn()
  533.         }
  534.     }
  535.  
  536.     fun tryWord(word: String, timeLeft : Long) {
  537.         val isWin = word.equals(this.word, true)
  538.         if (isWin) {
  539.             myWin = true
  540.             model.sendVideoGuessed(videoId)
  541.             model.increaseGameWin()
  542.             model.onGameWin(roomName)
  543.             val seconds = TimeUnit.MILLISECONDS.toSeconds(-timeLeft)
  544.             view.finish(FinishGameModel(isWin, videoId, word, App.getPreferences().getUsername(), 1, seconds, isRoom, roomName))
  545.         } else
  546.             view.showNotRightWord()
  547.  
  548.     }
  549.  
  550.     fun onTimeLeft() {
  551.         view.showTimeLeft(model.isEnoughScores())
  552.     }
  553.  
  554.     fun tryAgain() {
  555.         if (model.isEnoughScores()) {
  556.             if (model.changeScores(1) == 0) {
  557.                 view.disableAddLetterBtn()
  558.                 view.disableAddMinuteBtn()
  559.             }
  560.             view.startAgain()
  561.             view.updatePoints(model.getPointsValue().toString())
  562.         } else {
  563.             view.disableAddLetterBtn()
  564.             view.disableAddMinuteBtn()
  565.         }
  566.     }
  567.  
  568.     fun finish() {
  569.         view.finish(FinishGameModel(false, videoId, word, null, 1, 0, isRoom, roomName))
  570.     }
  571.  
  572.     fun videoStart() {
  573.         model.sendVideoWatch(videoId)
  574.     }
  575.  
  576.     fun onCloseRoom() {
  577.         if (roomName.isNotEmpty())
  578.             model.closeRoom(roomName)
  579.     }
  580.  
  581.     fun onLeaveRoom() {
  582.         if (roomName.isNotEmpty())
  583.             model.leaveRoom()
  584.     }
  585.  
  586.     fun destroy() {
  587.         disposable.clear()
  588.         model.clear()
  589.     }
  590. }
  591.  
  592.  
  593.  
  594. fun loginInRoom(roomName: String) {
  595.         addSubscription(model.loginRoom(roomName)
  596.             .subscribeOn(Schedulers.io())
  597.             .observeOn(AndroidSchedulers.mainThread())
  598.             .subscribe ({
  599.                 view.startGame(1, it)
  600.             }, {
  601.                 view.showSnackBar(it.message!!)
  602.             }))
  603.     }
  604.  
  605.  
  606. fun onCreateRoomConfirm(name: String, level: Int) {
  607.         addSubscription(model.createRoom(name, level)
  608.             .subscribeOn(Schedulers.io())
  609.             .observeOn(AndroidSchedulers.mainThread())
  610.             .subscribe ({
  611.                 view.startGame(level, it)
  612.             }, {
  613.                 it.printStackTrace()
  614.             }))
  615.     }
  616.  
  617.  
  618.  
  619. package com.mldz.igrodil.ui.fragments
  620.  
  621. import android.content.Intent
  622. import android.os.Bundle
  623. import android.provider.Settings
  624. import android.view.LayoutInflater
  625. import android.view.View
  626. import android.view.ViewGroup
  627. import com.afollestad.materialdialogs.MaterialDialog
  628. import com.afollestad.materialdialogs.input.input
  629. import com.afollestad.materialdialogs.list.listItemsSingleChoice
  630. import com.google.android.material.snackbar.Snackbar
  631. import com.mldz.igrodil.App
  632. import com.mldz.igrodil.R
  633. import com.mldz.igrodil.api.models.RoomModelItem
  634. import com.mldz.igrodil.managers.IgrodilManager
  635. import com.mldz.igrodil.managers.services.RoomService
  636. import com.mldz.igrodil.mvp.presenters.RoomFragmentPresenter
  637. import com.mldz.igrodil.mvp.views.RoomFragmentView
  638. import com.mldz.igrodil.ui.activities.GameActivity
  639. import com.mldz.igrodil.ui.adapters.RoomAdapter
  640. import com.mldz.igrodil.utils.replaceFragment
  641. import kotlinx.android.synthetic.main.fragment_room.view.*
  642.  
  643. class RoomFragment: BaseFragment(), RoomFragmentView, RoomAdapter.OnRoomClickListener {
  644.     private lateinit var presenter: RoomFragmentPresenter
  645.  
  646.     companion object {
  647.         fun newInstance(): RoomFragment {
  648.             val args = Bundle()
  649.             val fragment = RoomFragment()
  650.             fragment.arguments = args
  651.             return fragment
  652.         }
  653.     }
  654.  
  655.     override fun onCreateView(
  656.         inflater: LayoutInflater,
  657.         container: ViewGroup?,
  658.         savedInstanceState: Bundle?
  659.     ): View? {
  660.         val view = inflater.inflate(R.layout.fragment_room, container, false)
  661.         presenter = RoomFragmentPresenter(this)
  662.         view.btnCreateRoom.setOnClickListener {
  663.             presenter.onCreateRoomClick()
  664.         }
  665.         return view
  666.     }
  667.  
  668.     override fun onResume() {
  669.         super.onResume()
  670.         presenter.onCreate()
  671.     }
  672.  
  673.     override fun showLevelDialog() {
  674.         val levelItems = listOf(getString(R.string.lvl_simple), getString(R.string.lvl_hard))
  675.         var level = LevelGameFragment.LEVEL_ID_SIMPLE
  676.         var name = ""
  677. //        MaterialDialog(context!!).show {
  678. //            title(R.string.choose_level)
  679. //            listItemsSingleChoice(items = levelItems, initialSelection = 0, waitForPositiveButton = false) { s, i, text ->
  680. //                level = i + 1
  681. //            }
  682. //            positiveButton(android.R.string.ok) {
  683. //                presenter.onCreateRoomConfirm(level)
  684. //            }
  685. //            negativeButton(R.string.cancel)
  686. //        }
  687.  
  688.         MaterialDialog(context!!).show {
  689.             title(R.string.create_room)
  690.             listItemsSingleChoice(items = levelItems, initialSelection = 0, waitForPositiveButton = false) { dialog, index, text ->
  691.                 level = index + 1
  692.             }
  693.             input(waitForPositiveButton = false, allowEmpty = false, hintRes = R.string.room_name) { dialog, text ->
  694.                 name = text.toString()
  695.             }
  696.             positiveButton(android.R.string.ok) {
  697.                 presenter.onCreateRoomConfirm(name, level)
  698.             }
  699.             negativeButton(R.string.cancel)
  700.         }
  701.     }
  702.  
  703.     override fun setRooms(rooms: List<RoomModelItem>) {
  704.         view?.roomList?.adapter = RoomAdapter(rooms, this)
  705.     }
  706.  
  707.     override fun startGame(level: Int, room: HashMap<Int, String>) {
  708.         startRoomService(room[1]!!)
  709.         (activity as GameActivity?)?.replaceFragment(ProcessGameFragment.newInstance(level, GameActivity.GAME_TYPE_MULTI, room), R.id.frame, true)
  710.     }
  711.  
  712.     override fun showNoRooms() {
  713.         view?.emptyRoomList?.visibility = View.VISIBLE
  714.     }
  715.  
  716.     override fun hideNoRooms() {
  717.         view?.emptyRoomList?.visibility = View.GONE
  718.     }
  719.  
  720.     override fun showSnackBar(message: String) {
  721.         Snackbar.make(view?.mainLayout!!, message, Snackbar.LENGTH_SHORT).show()
  722.     }
  723.  
  724.     override fun disableCreateRoomButton() {
  725.         view?.btnCreateRoom?.isEnabled = false
  726.         view?.btnCreateRoom?.setOnClickListener { showSnackBar(context!!.getString(R.string.need_auth_to_create)) }
  727.     }
  728.  
  729.     override fun enableProgressBar(enabled: Boolean) {
  730.         when(enabled) {
  731.             true -> view?.progressBar?.visibility = View.VISIBLE
  732.             else -> view?.progressBar?.visibility = View.GONE
  733.         }
  734.     }
  735.  
  736.     override fun showNoInternet() {
  737.         view?.noInternet?.visibility = View.VISIBLE
  738.     }
  739.  
  740.     override fun onDestroy() {
  741.         super.onDestroy()
  742.         presenter.clearSubscriptions()
  743.     }
  744.  
  745.     override fun onClick(roomName: String) {
  746.         presenter.loginInRoom(roomName)
  747.     }
  748.  
  749.     private fun startRoomService(roomName: String) {
  750.         val playerName = if (App.getPreferences().isAuth()) {
  751.             App.getPreferences().getUsername()
  752.         } else {
  753.             Settings.Secure.getString(IgrodilManager.getContext().contentResolver, Settings.Secure.ANDROID_ID)
  754.         }
  755.         val intent = Intent(context!!, RoomService::class.java)
  756.         intent.putExtra("roomName", roomName)
  757.         intent.putExtra("playerName", playerName)
  758.         activity?.startService(intent)
  759.     }
  760. }
  761.  
  762.  
  763.  
  764. package com.mldz.igrodil.ui.fragments
  765.  
  766. import android.os.Build
  767. import android.os.Bundle
  768. import android.os.SystemClock
  769. import android.view.LayoutInflater
  770. import android.view.MenuItem
  771. import android.view.View
  772. import android.view.ViewGroup
  773. import android.widget.ArrayAdapter
  774. import androidx.appcompat.app.AlertDialog
  775. import androidx.core.text.HtmlCompat
  776. import androidx.core.widget.doOnTextChanged
  777. import com.afollestad.materialdialogs.MaterialDialog
  778. import com.google.android.exoplayer2.ExoPlayer
  779. import com.google.android.exoplayer2.Player
  780. import com.mldz.igrodil.App
  781. import com.mldz.igrodil.R
  782. import com.mldz.igrodil.api.models.FinishGameModel
  783. import com.mldz.igrodil.mvp.presenters.ProcessGameFragmentPresenter
  784. import com.mldz.igrodil.mvp.views.ProcessGameFragmentView
  785. import com.mldz.igrodil.ui.activities.GameActivity
  786. import com.mldz.igrodil.ui.dialogs.TimeLeftDialog
  787. import com.mldz.igrodil.utils.Define
  788. import com.mldz.igrodil.utils.replaceFragment
  789. import kotlinx.android.synthetic.main.fragment_process_game.view.*
  790.  
  791.  
  792. class ProcessGameFragment: BaseFragment(), ProcessGameFragmentView, Player.EventListener {
  793.     private val minute = 60000
  794.  
  795.     private var level: Int = 1
  796.     private var type = GameActivity.GAME_TYPE_SIMPLE
  797.     private lateinit var roomName: String
  798.     private lateinit var creator: String
  799.     private lateinit var fragmentPresenter: ProcessGameFragmentPresenter
  800.     private var timeLeftDialog: AlertDialog? = null
  801.     private var videoStart = false
  802.     private var isGame = false
  803.     private lateinit var videoPath: String
  804.  
  805.     companion object {
  806.         fun newInstance(level: Int, type: Int = GameActivity.GAME_TYPE_SIMPLE, room: HashMap<Int, String>): ProcessGameFragment{
  807.             val args = Bundle()
  808.             args.putInt(LevelGameFragment.LEVEL_ID_NAME, level)
  809.             args.putInt(GameActivity.GAME_TYPE_NAME, type)
  810.             args.putString("roomName", room[1])
  811.             args.putString("creator", room[0])
  812.             val fragment = ProcessGameFragment()
  813.             fragment.arguments = args
  814.             return fragment
  815.         }
  816.     }
  817.  
  818.     override fun onCreate(savedInstanceState: Bundle?) {
  819.         super.onCreate(savedInstanceState)
  820.         val args: Bundle? = arguments
  821.         level = args?.getInt(LevelGameFragment.LEVEL_ID_NAME) ?: LevelGameFragment.LEVEL_ID_SIMPLE
  822.         type = args?.getInt(GameActivity.GAME_TYPE_NAME) ?: GameActivity.GAME_TYPE_SIMPLE
  823.         roomName = args?.getString("roomName") ?: ""
  824.         creator = args?.getString("creator") ?: ""
  825.     }
  826.  
  827.     override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
  828.         val view = inflater.inflate(R.layout.fragment_process_game, container, false)
  829.         fragmentPresenter = ProcessGameFragmentPresenter(this)
  830.         fragmentPresenter.onCreate(type, roomName, level, creator)
  831.         setHasOptionsMenu(true)
  832.         view.btnSendWord.setOnClickListener {
  833.             fragmentPresenter.tryWord(
  834.                 view.word.text.toString().trim(),
  835.                 SystemClock.elapsedRealtime() - view!!.chronometer!!.base)
  836.         }
  837.         view.btnAddMinute.setOnClickListener { fragmentPresenter.addMinute() }
  838.         view.btnAddLetter.setOnClickListener { fragmentPresenter.addLetter() }
  839.         view.chronometer.setOnChronometerTickListener {
  840.             val elapsedMillis: Long = SystemClock.elapsedRealtime() - view.chronometer.base
  841.             if (elapsedMillis >= 0) {
  842.                 fragmentPresenter.onTimeLeft()
  843.             }
  844.         }
  845.         view.wordLayout.word?.doOnTextChanged { _, _, count, _ ->
  846.             if (count > 0) view.wordLayout.error = null
  847.         }
  848.         view.btnExit.setOnClickListener {
  849.             fragmentPresenter.onLeaveRoom()
  850.             (activity as GameActivity?)?.onBackPressed()
  851.         }
  852.         view.btnStopGame.setOnClickListener {
  853.             fragmentPresenter.onCloseRoom()
  854.             (activity as GameActivity?)?.onBackPressed()
  855.         }
  856.         view.btnStartGame.setOnClickListener {
  857.             isGame = true
  858.             fragmentPresenter.onRoomGameStart()
  859.         }
  860.         view.levelTitle.text = HtmlCompat.fromHtml(getString(R.string.level_desc, Define.levelNames[level]), HtmlCompat.FROM_HTML_MODE_LEGACY)
  861.         return view
  862.     }
  863.  
  864.     override fun addMinute() {
  865.         val elapsedMillis = SystemClock.elapsedRealtime() - view!!.chronometer!!.base
  866.         view?.chronometer?.base = SystemClock.elapsedRealtime() - elapsedMillis + minute
  867.     }
  868.  
  869.     override fun showLetter(word: String) {
  870.         view?.shownWord?.text = word
  871.     }
  872.  
  873.     override fun finish(data: FinishGameModel) {
  874.         data.level = level
  875.         (activity as GameActivity?)?.replaceFragment(FinishGameFragment.newInstance(data), R.id.frame, false)
  876.     }
  877.  
  878.     override fun setVideo(path: String) {
  879.         videoPath = path
  880.         fragmentPresenter.play(path)
  881.         fragmentPresenter.videoStart()
  882.         view?.btnExit?.visibility = View.GONE
  883.     }
  884.  
  885.     override fun showTimeLeft(canRepeat: Boolean) {
  886.         view?.chronometer?.stop()
  887.         view?.videoPlayer?.player?.playWhenReady = false
  888.         if (timeLeftDialog == null) {
  889.             timeLeftDialog = TimeLeftDialog(context!!).apply {
  890.                 cancelable = false
  891.                 if (!canRepeat) {
  892.                     makeTryAgainDisable()
  893.                 } else {
  894.                     tryAgainClickListener {
  895.                         timeLeftDialog = null
  896.                         fragmentPresenter.tryAgain()
  897.                     }
  898.                 }
  899.                 closeClickListener {
  900.                     fragmentPresenter.finish()
  901.                 }
  902.  
  903.             }.create()
  904.             timeLeftDialog!!.show()
  905.         }
  906.     }
  907.  
  908.     override fun disableAddMinuteBtn() {
  909.         view?.btnAddMinute?.isClickable = false
  910.         view?.btnAddMinute?.setBackgroundColor(resources.getColor(R.color.colorAccent))
  911.     }
  912.  
  913.     override fun disableAddLetterBtn() {
  914.         view?.btnAddLetter?.isClickable = false
  915.         view?.btnAddLetter?.setBackgroundColor(resources.getColor(R.color.colorAccent))
  916.     }
  917.  
  918.     override fun showNotRightWord() {
  919.         view?.wordLayout?.error = getString(R.string.try_again)
  920.     }
  921.  
  922.     override fun updatePoints(points: String) {
  923.         (activity as GameActivity?)?.updatePoints(points)
  924.     }
  925.  
  926.     override fun startAgain() {
  927.         view?.chronometer?.stop()
  928.         view?.chronometer?.base = SystemClock.elapsedRealtime() + minute
  929.         view?.chronometer?.start()
  930.         view?.videoPlayer?.player?.playWhenReady = true
  931.     }
  932.  
  933.     override fun showWaitPlayers(isCreator: Boolean) {
  934.         view?.gameLayout?.visibility = View.GONE
  935.         view?.waitPlayersLayout?.visibility = View.VISIBLE
  936.         when(isCreator) {
  937.             true -> view?.btnExit?.visibility = View.GONE
  938.             else -> {
  939.                 view?.btnStartGame?.visibility = View.GONE
  940.                 view?.btnStopGame?.visibility = View.GONE
  941.             }
  942.         }
  943.     }
  944.  
  945.     override fun hideWaitPlayers() {
  946.         view?.gameLayout?.visibility = View.VISIBLE
  947.         view?.waitPlayersLayout?.visibility = View.GONE
  948.     }
  949.  
  950.     override fun updateUsers(users: ArrayList<String>) {
  951.         val adapter = ArrayAdapter(context!!, android.R.layout.simple_list_item_1, users)
  952.         view?.playersList?.adapter = adapter
  953.         view?.playersCount?.text = getString(R.string.players_count, users.size)
  954.     }
  955.  
  956.     override fun onCloseRoom() {
  957.         if (roomName == App.getPreferences().getUsername())
  958.             (activity as GameActivity?)?.onBackPressed()
  959.         else {
  960.             MaterialDialog(context!!).show {
  961.                 title(R.string.room_close)
  962.                 message(R.string.room_close_desc)
  963.                 positiveButton(android.R.string.ok) {
  964.                     (activity as GameActivity?)?.onBackPressed()
  965.                 }
  966.             }
  967.         }
  968.     }
  969.  
  970.     override fun enableProgressBar(enabled: Boolean) {
  971.         when(enabled) {
  972.             true -> {
  973.                 view?.progressBar?.visibility = View.VISIBLE
  974.                 view?.gameLayout?.visibility = View.GONE
  975.             }
  976.             else -> {
  977.                 view?.progressBar?.visibility = View.GONE
  978.                 view?.gameLayout?.visibility = View.VISIBLE
  979.             }
  980.         }
  981.     }
  982.  
  983.     override fun showNoInternet() {
  984.         view?.noInternet?.visibility = View.VISIBLE
  985.         view?.gameLayout?.visibility = View.GONE
  986.     }
  987.  
  988.     override fun onPlayerStateChanged(playWhenReady: Boolean, playbackState: Int) {
  989.         super.onPlayerStateChanged(playWhenReady, playbackState)
  990.         when (playbackState) {
  991.             ExoPlayer.STATE_IDLE -> view?.videoProgressBar?.visibility = View.VISIBLE
  992.             ExoPlayer.STATE_BUFFERING -> view?.videoProgressBar?.visibility = View.VISIBLE
  993.             ExoPlayer.STATE_READY -> {
  994.                 view?.videoProgressBar?.visibility = View.GONE
  995.                 if (!videoStart) {
  996.                     videoStart = true
  997.                     view?.chronometer?.base = SystemClock.elapsedRealtime() + minute
  998.                     view?.chronometer?.start()
  999.                     view?.progressBarButtons?.visibility = View.GONE
  1000.                     view?.btnLayout?.visibility = View.VISIBLE
  1001.                 }
  1002.             }
  1003.             ExoPlayer.STATE_ENDED -> view?.videoProgressBar?.visibility = View.GONE
  1004.         }
  1005.     }
  1006.  
  1007.     override fun onOptionsItemSelected(item: MenuItem): Boolean {
  1008.         when(item.itemId) {
  1009.             android.R.id.home -> {
  1010.                 (activity as GameActivity?)?.onBackPressed()
  1011.             }
  1012.         }
  1013.         return super.onOptionsItemSelected(item)
  1014.     }
  1015.  
  1016.     override fun onResume() {
  1017.         super.onResume()
  1018.         (activity as GameActivity?)?.changeToolbarColor(false)
  1019.         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) {
  1020.             view?.videoPlayer?.player = fragmentPresenter.getPlayer().getPlayerImpl(context!!, this)
  1021.             if (this::videoPath.isInitialized)
  1022.                 fragmentPresenter.play(videoPath)
  1023.         }
  1024.     }
  1025.  
  1026.     override fun onStart() {
  1027.         super.onStart()
  1028.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
  1029.             view?.videoPlayer?.player = fragmentPresenter.getPlayer().getPlayerImpl(context!!, this)
  1030.             if (this::videoPath.isInitialized)
  1031.                 fragmentPresenter.play(videoPath)
  1032.         }
  1033.     }
  1034.  
  1035.     override fun onPause() {
  1036.         super.onPause()
  1037.         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) {
  1038.             fragmentPresenter.releasePlayer()
  1039.         }
  1040.     }
  1041.  
  1042.     override fun onStop() {
  1043.         super.onStop()
  1044.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
  1045.             fragmentPresenter.releasePlayer()
  1046.         }
  1047.     }
  1048.  
  1049.     override fun onDestroy() {
  1050.         super.onDestroy()
  1051.         fragmentPresenter.destroy()
  1052.         (activity as GameActivity?)?.changeToolbarColor(true)
  1053.     }
  1054. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!