content
stringlengths 0
3.9M
| path
stringlengths 4
242
| contentHash
stringlengths 1
10
|
|---|---|---|
package com.image.editor
import android.content.Context
import android.graphics.Bitmap
import android.graphics.Canvas
import android.graphics.Matrix
import android.graphics.Paint
import android.graphics.PointF
import android.graphics.RectF
import android.graphics.drawable.BitmapDrawable
import android.util.AttributeSet
import android.view.MotionEvent
import androidx.appcompat.widget.AppCompatImageView
class CustomImageEditingView @JvmOverloads constructor(
context: Context,
attrs: AttributeSet? = null,
defStyle: Int = 0
) : AppCompatImageView(context, attrs, defStyle) {
enum class Mode {
NONE, DRAG, RESIZE, CROP, SKEW, ALPHA
}
private var currentMatrix = Matrix()
private var cropMatrix = Matrix()
private var savedMatrix = Matrix()
private var mode: Mode = Mode.DRAG
//PointF objects are used to record the point(s) the user is touching
private var startPoint = PointF()
// Variables to store crop area
private var cropStartPoint = PointF()
private var cropEndPoint = PointF()
init {
scaleType = ScaleType.MATRIX
post {
currentMatrix.set(savedMatrix)
imageMatrix = currentMatrix
}
}
private var skewMatrix = Matrix()
private var startCornerPoint = PointF()
private val minWidth = 10
private val minHeight = 10
private val cropPaint = Paint().apply {
color = context.getColor(R.color.black)
style = Paint.Style.STROKE
strokeWidth = 4f
}
private val paint = Paint().apply {
color = context.getColor(R.color.primary)
style = Paint.Style.FILL
strokeWidth = 10f
strokeCap = Paint.Cap.ROUND
}
private val gridPaint = Paint().apply {
color = context.getColor(R.color.primary)
strokeWidth = 3f
alpha = 70
}
/**
* set current mode
*/
fun setMode(mode: Mode) {
this.mode = mode
if (mode == Mode.CROP) {
prepareCropFrame()
}
invalidate()
}
/**
* get current mode
*/
fun getCurrentMode(): Mode {
return mode
}
private fun prepareCropFrame() {
cropMatrix = Matrix(currentMatrix)
val cropRect = calculateImageRect(cropMatrix)
cropStartPoint = PointF(cropRect.left, cropRect.top)
cropEndPoint = PointF(cropRect.right, cropRect.bottom)
}
override fun onTouchEvent(event: MotionEvent): Boolean {
val matrixValues = FloatArray(9)
currentMatrix.getValues(matrixValues)
val imageRect = calculateImageRect(currentMatrix)
val cropRect = calculateImageRect(cropMatrix)
when (event.action) {
MotionEvent.ACTION_DOWN -> {
savedMatrix.set(currentMatrix)
startPoint.set(event.x, event.y)
// Check if the touch is on any of the corners
if (mode == Mode.RESIZE && isTouchOnHandle(
event.x,
event.y,
imageRect
) !== Handle.NONE
) {
startCornerPoint.set(event.x, event.y)
} else if (mode == Mode.CROP) {
startCornerPoint.set(event.x, event.y)
}
}
MotionEvent.ACTION_MOVE -> {
if (mode == Mode.DRAG) {
currentMatrix.set(savedMatrix)
currentMatrix.postTranslate(
event.x - startPoint.x,
event.y - startPoint.y
)
} else if (mode == Mode.RESIZE && isTouchOnHandle(
event.x,
event.y,
imageRect
) !== Handle.NONE
) {
if (startCornerPoint.x == 0f && startCornerPoint.y == 0f) {
startCornerPoint.set(event.x, event.y)
}
calculateAndUpdateMatrix(imageRect, currentMatrix, event.x, event.y)
} else if (mode == Mode.CROP) {
if (isPointInsideCropRect(event.x, event.y)) {
calculateAndUpdateMatrix(cropRect, cropMatrix, event.x, event.y)
invalidate()
}
}
}
MotionEvent.ACTION_UP, MotionEvent.ACTION_POINTER_UP -> {
if (mode == Mode.RESIZE) {
startCornerPoint.set(0f, 0f)
} else if (mode == Mode.CROP) {
val rect = calculateImageRect(cropMatrix)
cropStartPoint = PointF(rect.left, rect.top)
cropEndPoint = PointF(rect.right, rect.bottom)
}
}
}
imageMatrix = currentMatrix
return true
}
/**
* It will skew image based on input from slider
* */
fun skewImage(horizontal: Float, vertical: Float, isTop: Boolean) {
val imageRect = calculateImageRect(currentMatrix)
skewMatrix = Matrix()
skewMatrix.set(currentMatrix)
// Apply skewing only to the top part of the image
if (horizontal == 0f) {
if (isTop) {
skewMatrix.postSkew(0f, vertical, imageRect.left, imageRect.top)
} else {
skewMatrix.postSkew(0f, vertical, imageRect.right, imageRect.bottom)
}
} else {
if (isTop) {
skewMatrix.postSkew(horizontal, 0f, imageRect.right, imageRect.bottom)
} else {
skewMatrix.postSkew(horizontal, 0f, imageRect.left, imageRect.top)
}
}
imageMatrix = skewMatrix
invalidate()
}
/**
* Check if crop area is not moving outside of image
*/
private fun isPointInsideCropRect(x: Float, y: Float): Boolean {
val imageRect = calculateImageRect(currentMatrix)
return imageRect.contains(x, y)
}
/**
* Move the picked corner and update the matrix accordingly
* For Crop frame or resizing image
*/
private fun calculateAndUpdateMatrix(
rect: RectF,
matrix: Matrix,
pointX: Float,
pointY: Float
) {
val dx = (pointX - startCornerPoint.x)
val dy = (pointY - startCornerPoint.y)
val width = rect.width()
val height = rect.height()
val newWidth: Float
val newHeight: Float
val pivotX: Float
val pivotY: Float
when (isTouchOnHandle(pointX, pointY, rect)) {
Handle.TOP_LEFT -> {
newWidth = width - dx
newHeight = height - dy
pivotX = rect.right
pivotY = rect.bottom
}
Handle.TOP_RIGHT -> {
newWidth = width + dx
newHeight = height - dy
pivotX = rect.left
pivotY = rect.bottom
}
Handle.BOTTOM_LEFT -> {
newWidth = width - dx
newHeight = height + dy
pivotX = rect.right
pivotY = rect.top
}
Handle.BOTTOM_RIGHT -> {
newWidth = width + dx
newHeight = height + dy
pivotX = rect.left
pivotY = rect.top
}
Handle.TOP -> {
newWidth = width
newHeight = height - dy
pivotX = (rect.left + rect.right) / 2 // Keep X coordinate unchanged
pivotY = rect.bottom
}
Handle.BOTTOM -> {
newWidth = width
newHeight = height + dy
pivotX = (rect.left + rect.right) / 2 // Keep X coordinate unchanged
pivotY = rect.top
}
Handle.LEFT -> {
newWidth = width - dx
newHeight = height
pivotX = rect.right
pivotY = (rect.top + rect.bottom) / 2 // Keep Y coordinate unchanged
}
Handle.RIGHT -> {
newWidth = width + dx
newHeight = height
pivotX = rect.left
pivotY = (rect.top + rect.bottom) / 2 // Keep Y coordinate unchanged
}
else -> {
newWidth = width.toFloat()
newHeight = height.toFloat()
pivotX = pointX
pivotY = pointY
}
}
if (newWidth > minWidth && newHeight > minHeight) {
// Calculate the scaling factors based on the change in width and height
val scaleX = newWidth / width
val scaleY = newHeight / height
// Apply scaling
matrix.postScale(
scaleX,
scaleY,
pivotX,
pivotY
)
startCornerPoint.set(pointX, pointY)
}
}
/**
* Crop and set image new bitmap to view
*/
fun cropAndSetImage() {
val croppedBitmap = cropImage()
setImageBitmap(croppedBitmap)
val translationX = cropStartPoint.x
val translationY = cropStartPoint.y
currentMatrix = Matrix()
// Apply the translation to the current matrix
currentMatrix.postTranslate(translationX, translationY)
// Set the adjusted matrix to the image view
imageMatrix = currentMatrix
cropMatrix.reset()
invalidate()
setMode(Mode.DRAG)
}
/**
* calculate and crop area of image using updated
* crop matrix
*/
private fun cropImage(): Bitmap? {
// Get the visible rectangle of the image
val imageRect = calculateImageRect(currentMatrix)
// Calculate the intersection between the crop area and the image bounds
val cropRect = RectF(
cropStartPoint.x.coerceIn(imageRect.left, imageRect.right),
cropStartPoint.y.coerceIn(imageRect.top, imageRect.bottom),
cropEndPoint.x.coerceIn(imageRect.left, imageRect.right),
cropEndPoint.y.coerceIn(imageRect.top, imageRect.bottom)
)
// Check if the crop area has valid dimensions
if (cropRect.width() < minWidth || cropRect.height() < minHeight) {
// Invalid crop area
return null
}
// Create a bitmap representing the current state of the image with transformations applied
val drawable = drawable ?: return null
val bitmap = (drawable as BitmapDrawable).bitmap
val transformedBitmap =
Bitmap.createBitmap(bitmap, 0, 0, bitmap.width, bitmap.height, currentMatrix, true)
// Calculate the dimensions of the crop area in bitmap coordinates
val cropLeft =
((cropRect.left - imageRect.left) / imageRect.width() * transformedBitmap.width).toInt()
val cropTop =
((cropRect.top - imageRect.top) / imageRect.height() * transformedBitmap.height).toInt()
val cropWidth = (cropRect.width() / imageRect.width() * transformedBitmap.width).toInt()
val cropHeight = (cropRect.height() / imageRect.height() * transformedBitmap.height).toInt()
val croppedBitmap =
Bitmap.createBitmap(transformedBitmap, cropLeft, cropTop, cropWidth, cropHeight)
return croppedBitmap
}
/**
* this function flip the image matrix to horizontally
* to opposite direction that currently
*/
fun flipHorizontally() {
val matrix = Matrix(currentMatrix)
val imageRect = calculateImageRect(currentMatrix)
// Calculate the original center point of the image
val originalCenterX = (imageRect.right + imageRect.left) / 2
val originalCenterY = (imageRect.bottom + imageRect.top) / 2
// Flip horizontally
matrix.postScale(-1f, 1f, originalCenterX, originalCenterY)
currentMatrix.set(matrix)
imageMatrix = currentMatrix
}
private enum class Handle {
TOP,
LEFT,
RIGHT,
BOTTOM,
TOP_LEFT,
TOP_RIGHT,
BOTTOM_LEFT,
BOTTOM_RIGHT,
NONE
}
/**
* Draw crop or resize frame over image
*/
override fun onDraw(canvas: Canvas) {
super.onDraw(canvas)
if (drawable == null) {
return
}
canvas.apply {
if (mode == Mode.RESIZE) {
val imageRect = calculateImageRect(currentMatrix)
canvas.drawRect(imageRect, cropPaint)
drawHandles(imageRect, paint)
} else if (mode == Mode.CROP) {
val cropRect = calculateImageRect(cropMatrix)
canvas.drawRect(cropRect, cropPaint)
drawHandles(cropRect, paint)
drawGridLines(cropRect, gridPaint)
}
}
}
/**
* Will identify if user picked corner and will return which handle is picked
*/
private fun isTouchOnHandle(
x: Float,
y: Float,
imageRect: RectF,
handleLength: Float = 70f
): Handle {
// Define the regions for each handle
val topHandleRegion = RectF(
(imageRect.left + imageRect.right - handleLength) / 2,
imageRect.top - handleLength / 2,
(imageRect.left + imageRect.right + handleLength) / 2,
imageRect.top + handleLength / 2
)
val bottomHandleRegion = RectF(
(imageRect.left + imageRect.right - handleLength) / 2,
imageRect.bottom - handleLength / 2,
(imageRect.left + imageRect.right + handleLength) / 2,
imageRect.bottom + handleLength / 2
)
val leftHandleRegion = RectF(
imageRect.left - handleLength / 2,
(imageRect.top + imageRect.bottom - handleLength) / 2,
imageRect.left + handleLength / 2,
(imageRect.top + imageRect.bottom + handleLength) / 2
)
val rightHandleRegion = RectF(
imageRect.right - handleLength / 2,
(imageRect.top + imageRect.bottom - handleLength) / 2,
imageRect.right + handleLength / 2,
(imageRect.top + imageRect.bottom + handleLength) / 2
)
val leftTopCorner = RectF(
imageRect.left - handleLength,
imageRect.top - handleLength,
imageRect.left + handleLength,
imageRect.top + handleLength
)
val rightTopCorner = RectF(
imageRect.right - handleLength,
imageRect.top - handleLength,
imageRect.right + handleLength,
imageRect.top + handleLength
)
val leftBottomCorner = RectF(
imageRect.left - handleLength,
imageRect.bottom - handleLength,
imageRect.left + handleLength,
imageRect.bottom + handleLength
)
val rightBottomCorner = RectF(
imageRect.right - handleLength,
imageRect.bottom - handleLength,
imageRect.right + handleLength,
imageRect.bottom + handleLength
)
// Check if the touch coordinates lie within any handle region
return when {
leftTopCorner.contains(x, y) -> Handle.TOP_LEFT
rightTopCorner.contains(x, y) -> Handle.TOP_RIGHT
leftBottomCorner.contains(x, y) -> Handle.BOTTOM_LEFT
rightBottomCorner.contains(x, y) -> Handle.BOTTOM_RIGHT
topHandleRegion.contains(x, y) -> Handle.TOP
bottomHandleRegion.contains(x, y) -> Handle.BOTTOM
leftHandleRegion.contains(x, y) -> Handle.LEFT
rightHandleRegion.contains(x, y) -> Handle.RIGHT
else -> Handle.NONE
}
}
/**
* Calculate RecF bitmap image
*/
private fun calculateImageRect(matrixValues: Matrix): RectF {
val drawable = drawable
val imageRect =
RectF(0f, 0f, drawable.intrinsicWidth.toFloat(), drawable.intrinsicHeight.toFloat())
matrixValues.mapRect(imageRect)
return imageRect
}
/**
* Update current matrix with skew applied
*/
fun skewImageUpdate() {
currentMatrix.set(skewMatrix)
imageMatrix = currentMatrix
invalidate()
}
}
| Image-editor-tools/app/src/main/java/com/image/editor/CustomImageEditingView.kt | 325467305 |
package kr.co.lion.homework_memoapplication_leekyungsoo
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("kr.co.lion.homework_memoapplication_leekyungsoo", appContext.packageName)
}
} | Homework_MemoApplication_LeeKyungSoo/app/src/androidTest/java/kr/co/lion/homework_memoapplication_leekyungsoo/ExampleInstrumentedTest.kt | 3683903218 |
package kr.co.lion.homework_memoapplication_leekyungsoo
import org.junit.Test
import org.junit.Assert.*
/**
* Example local unit test, which will execute on the development machine (host).
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
class ExampleUnitTest {
@Test
fun addition_isCorrect() {
assertEquals(4, 2 + 2)
}
} | Homework_MemoApplication_LeeKyungSoo/app/src/test/java/kr/co/lion/homework_memoapplication_leekyungsoo/ExampleUnitTest.kt | 2067372513 |
package kr.co.lion.homework_memoapplication_leekyungsoo
import android.content.Intent
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import androidx.activity.result.ActivityResultLauncher
import androidx.activity.result.contract.ActivityResultContracts
import kr.co.lion.homework_memoapplication_leekyungsoo.databinding.ActivityShowBinding
class ShowActivity : AppCompatActivity() {
lateinit var activityShowBinding: ActivityShowBinding
// Activity 런쳐
lateinit var modifyActivityLauncher: ActivityResultLauncher<Intent>
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
activityShowBinding = ActivityShowBinding.inflate(layoutInflater)
setContentView(activityShowBinding.root)
setLauncher()
setToolbar()
setView()
}
// 런처 설정
fun setLauncher(){
// ModifyActivity Launcher
val contract1 = ActivityResultContracts.StartActivityForResult()
modifyActivityLauncher = registerForActivityResult(contract1){
}
}
fun setToolbar(){
activityShowBinding.apply {
toolbarShow.apply {
// 제목 설정
title = "메모 보기"
// Back 버튼
setNavigationIcon(R.drawable.arrow_back_24px)
setNavigationOnClickListener {
setResult(RESULT_CANCELED)
finish()
}
// 메뉴
inflateMenu(R.menu.menu_show)
// 메뉴 클릭 리스너
setOnMenuItemClickListener {
// 메뉴 id 별로 분기
when(it.itemId){
// 수정 (ModifyActivity로 객체 전달)
R.id.menu_item_show_modify -> {
val modifyIntent = Intent(this@ShowActivity, ModifyActivity::class.java)
// MainActivity에서 넘겨받은 position을 받아온다.
val position = intent.getIntExtra("position", 0)
// 받아온 position을 ModifyActivity로 넘겨준다.
modifyIntent.putExtra("position", position)
// 동물의 position을 intent에 담아서 ModifyActivity로 전달한다.
modifyActivityLauncher.launch(modifyIntent)
}
// 삭제
R.id.menu_item_show_delete -> {
// MainActivity로부터 삭제할 항목 순서 값을 가져온다.
val position = intent.getIntExtra("position", 0)
// 항목번째 객체를 리스트에서 제거한다.
Util.memoList.removeAt(position)
finish()
}
}
true
}
}
}
}
fun setView(){
activityShowBinding.apply {
// 항목의 순서값을 가져온다.
val position = intent.getIntExtra("position", 0)
// 포지션번째의 객체를 추출한다.
val memo = Util.memoList[position]
textViewShowTitle.text = memo.title
textViewShowContent.text = memo.content
textViewShowDate.text = memo.date
}
}
override fun onResume() {
super.onResume()
// 수정을 하고 다시 돌아왔을 때 View를 재구성함
setView()
}
} | Homework_MemoApplication_LeeKyungSoo/app/src/main/java/kr/co/lion/homework_memoapplication_leekyungsoo/ShowActivity.kt | 100729603 |
package kr.co.lion.homework_memoapplication_leekyungsoo
import android.content.Intent
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import android.view.ViewGroup
import androidx.activity.result.ActivityResultLauncher
import androidx.activity.result.contract.ActivityResultContracts
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import com.google.android.material.divider.MaterialDividerItemDecoration
import kr.co.lion.homework_memoapplication_leekyungsoo.databinding.ActivityMainBinding
import kr.co.lion.homework_memoapplication_leekyungsoo.databinding.RowMainBinding
class MainActivity : AppCompatActivity() {
private lateinit var activityMainBinding: ActivityMainBinding
// Activity 런쳐
private lateinit var writeActivityLauncher: ActivityResultLauncher<Intent>
lateinit var showActivityLauncher: ActivityResultLauncher<Intent>
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
activityMainBinding = ActivityMainBinding.inflate(layoutInflater)
setContentView(activityMainBinding.root)
setLauncher()
setToolbar()
setView()
}
// 화면 갱신
override fun onResume() {
super.onResume()
activityMainBinding.apply {
activityMainBinding.recyclerViewMain.adapter?.notifyDataSetChanged()
}
}
// 런처 설정
private fun setLauncher(){
// writeActivity 런처
val contract1 = ActivityResultContracts.StartActivityForResult()
writeActivityLauncher = registerForActivityResult(contract1){
}
// ShowActivity 런처
val contract2 = ActivityResultContracts.StartActivityForResult()
showActivityLauncher = registerForActivityResult(contract2){
}
}
// 툴바 설정
private fun setToolbar(){
activityMainBinding.apply {
toolbarMain.apply {
// 제목 설정
title = "메모 관리"
// 메뉴
inflateMenu(R.menu.menu_main)
// 추가 버튼 눌렀을 때
setOnMenuItemClickListener {
// 메뉴가 추가될 수도 있으니 id로 분기
when(it.itemId){
R.id.menu_item_main_add -> {
// 메모 작성 Activity로 이동
val writeIntent = Intent(this@MainActivity, WriteActivity::class.java)
writeActivityLauncher.launch(writeIntent)
}
}
true
}
}
}
}
// 뷰 설정
private fun setView(){
activityMainBinding.apply {
// RecyclerView
recyclerViewMain.apply {
// 어댑터
adapter = RecyclerViewMainAdapter()
// 레이아웃 매니저
layoutManager = LinearLayoutManager(this@MainActivity)
// 데코레이션
val deco = MaterialDividerItemDecoration(this@MainActivity, MaterialDividerItemDecoration.VERTICAL)
addItemDecoration(deco)
}
}
}
// RecyclerView의 어댑터
inner class RecyclerViewMainAdapter : RecyclerView.Adapter<RecyclerViewMainAdapter.ViewHolderMain>() {
// ViewHolder
inner class ViewHolderMain(rowMainBinding: RowMainBinding) :
RecyclerView.ViewHolder(rowMainBinding.root) {
val rowMainBinding: RowMainBinding
init {
this.rowMainBinding = rowMainBinding
this.rowMainBinding.root.layoutParams = ViewGroup.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.WRAP_CONTENT
)
}
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolderMain {
val rowMainBinding = RowMainBinding.inflate(layoutInflater)
val viewHolderMain = ViewHolderMain(rowMainBinding)
return viewHolderMain
}
override fun getItemCount(): Int {
return Util.memoList.size
}
override fun onBindViewHolder(holder: ViewHolderMain, position: Int) {
val memo = Util.memoList[position]
Log.d("test1235", position.toString())
// 제목과 작성 날짜를 보여준다
holder.rowMainBinding.textViewRowMainTitle.text = memo.title
holder.rowMainBinding.textViewRowMainDate.text = memo.date
holder.rowMainBinding.root.setOnClickListener{
val showIntent = Intent(this@MainActivity, ShowActivity::class.java)
// 객체를 전달한다.
val obj = Util.memoList[position]
// Util.memoList 리스트에 몇번째에 있는 값인지를 담아준다.
showIntent.putExtra("position", position)
// Position 번째에 있는 객체를 담아준다.
showIntent.putExtra("obj", obj)
showActivityLauncher.launch(showIntent)
}
}
}
} | Homework_MemoApplication_LeeKyungSoo/app/src/main/java/kr/co/lion/homework_memoapplication_leekyungsoo/MainActivity.kt | 3783118877 |
package kr.co.lion.homework_memoapplication_leekyungsoo
import android.content.DialogInterface
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import kr.co.lion.homework_memoapplication_leekyungsoo.databinding.ActivityWriteBinding
import java.text.SimpleDateFormat
import java.util.Calendar
import java.util.Locale
class WriteActivity : AppCompatActivity() {
lateinit var activityWriteBinding: ActivityWriteBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
activityWriteBinding = ActivityWriteBinding.inflate(layoutInflater)
setContentView(activityWriteBinding.root)
setToolbar()
initView()
}
// 툴바 설정
fun setToolbar(){
activityWriteBinding.apply {
toolbarWrite.apply {
// 제목
title = "메모 작성"
// Back 버튼
setNavigationIcon(R.drawable.arrow_back_24px)
setNavigationOnClickListener {
setResult(RESULT_CANCELED)
finish()
}
// 메뉴
inflateMenu(R.menu.menu_write)
setOnMenuItemClickListener {
checkInput()
true
}
}
}
}
// title에 키보드가 올라오도록 설정
fun initView(){
Util.showSoftInput(activityWriteBinding.textFieldInputTitle, this@WriteActivity)
}
// 입력 유효성 검사
fun checkInput(){
activityWriteBinding.apply {
val title = textFieldInputTitle.text.toString()
if (title.trim().isEmpty()) {
Util.showInfoDialog(this@WriteActivity, "제목 입력 오류", "제목을 입력해주세요"){ _: DialogInterface, _: Int ->
Util.showSoftInput(textFieldInputTitle, this@WriteActivity)
}
return
}
val content = textFieldInputContent.text.toString()
if (content.trim().isEmpty()) {
Util.showInfoDialog(this@WriteActivity, "내용 입력 오류", "내용을 입력해주세요"){ _: DialogInterface, _: Int ->
Util.showSoftInput(textFieldInputContent, this@WriteActivity)
}
return
}
addMemoData()
finish()
}
}
// 저장 처리
fun addMemoData(){
activityWriteBinding.apply {
val memo = Memo()
memo.title = textFieldInputTitle.text.toString()
memo.content = textFieldInputContent.text.toString()
val calendar = Calendar.getInstance()
val dateFormat = SimpleDateFormat("yyyy-MM-dd", Locale.getDefault())
memo.date = dateFormat.format(calendar.time)
// 메모 리스트에 메모를 추가한다.
Util.memoList.add(memo)
Log.d("test1234", memo.date)
Log.d("test1234", Util.memoList[0].date)
}
}
} | Homework_MemoApplication_LeeKyungSoo/app/src/main/java/kr/co/lion/homework_memoapplication_leekyungsoo/WriteActivity.kt | 2378508633 |
package kr.co.lion.homework_memoapplication_leekyungsoo
import android.content.DialogInterface
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import kr.co.lion.homework_memoapplication_leekyungsoo.databinding.ActivityModifyBinding
import java.text.SimpleDateFormat
import java.util.Calendar
import java.util.Locale
class ModifyActivity : AppCompatActivity() {
lateinit var activityModifyBinding: ActivityModifyBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
activityModifyBinding = ActivityModifyBinding.inflate(layoutInflater)
setContentView(activityModifyBinding.root)
setToolbar()
initView()
}
// 툴바 설정
fun setToolbar(){
activityModifyBinding.apply {
toolbarModify.apply {
title = "메모 수정"
// Back 버튼 설정
setNavigationIcon(R.drawable.arrow_back_24px)
setNavigationOnClickListener {
setResult(RESULT_CANCELED)
finish()
}
// 메뉴
inflateMenu(R.menu.menu_modify)
// 완료 버튼 클릭
setOnMenuItemClickListener {
checkInput()
true
}
}
}
}
// 초기에 제목, 내용을 가져와서 설정
fun initView(){
activityModifyBinding.apply {
// 순서 값 추출
val position = intent.getIntExtra("position", 0)
// position번째 Memo 추출
val memo = Util.memoList[position]
textFieldModifyTitle.setText(memo.title)
textFieldModifyContent.setText(memo.content)
}
}
// 수정 처리
fun modifyData(){
// 위치값을 가져온다.
val position = intent.getIntExtra("position", 0)
// position번째 객체를 가져온다.
val memo = Util.memoList[position]
activityModifyBinding.apply {
memo.title = textFieldModifyTitle.text.toString()
memo.content = textFieldModifyContent.text.toString()
val calendar = Calendar.getInstance()
val dateFormat = SimpleDateFormat("yyyy-MM-dd", Locale.getDefault())
memo.date = dateFormat.format(calendar.time)
}
}
// 입력 유효성 검사
fun checkInput(){
activityModifyBinding.apply {
val title = textFieldModifyTitle.text.toString()
if (title.trim().isEmpty()) {
Util.showInfoDialog(this@ModifyActivity, "제목 입력 오류", "제목을 입력해주세요"){ _: DialogInterface, _: Int ->
Util.showSoftInput(textFieldModifyTitle, this@ModifyActivity)
}
return
}
val content = textFieldModifyContent.text.toString()
if (content.trim().isEmpty()) {
Util.showInfoDialog(this@ModifyActivity, "내용 입력 오류", "내용을 입력해주세요"){ _: DialogInterface, _: Int ->
Util.showSoftInput(textFieldModifyContent, this@ModifyActivity)
}
return
}
}
modifyData()
finish()
}
} | Homework_MemoApplication_LeeKyungSoo/app/src/main/java/kr/co/lion/homework_memoapplication_leekyungsoo/ModifyActivity.kt | 366874047 |
package kr.co.lion.homework_memoapplication_leekyungsoo
import android.content.Context
import android.content.DialogInterface
import android.os.SystemClock
import android.view.View
import android.view.inputmethod.InputMethodManager
import androidx.appcompat.app.AppCompatActivity
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import kotlin.concurrent.thread
class Util {
companion object {
// 메모 객체들을 담을 리스트
val memoList = mutableListOf<Memo>()
fun showSoftInput(view: View, context: Context) {
// 포커스를 준다.
view.requestFocus()
thread {
SystemClock.sleep(1000)
val inputMethodManager =
context.getSystemService(AppCompatActivity.INPUT_METHOD_SERVICE) as InputMethodManager
inputMethodManager.showSoftInput(view, 0)
}
}
// 안내를 위한 다이얼로그
fun showInfoDialog(
context: Context,
title: String,
message: String,
listener: (DialogInterface, Int) -> Unit
) {
val dialogBuilder = MaterialAlertDialogBuilder(context)
dialogBuilder.setTitle(title)
dialogBuilder.setMessage(message)
dialogBuilder.setPositiveButton("확인", listener)
dialogBuilder.show()
}
}
} | Homework_MemoApplication_LeeKyungSoo/app/src/main/java/kr/co/lion/homework_memoapplication_leekyungsoo/Util.kt | 4061802506 |
package kr.co.lion.homework_memoapplication_leekyungsoo
import android.os.Parcel
import android.os.Parcelable
import java.text.SimpleDateFormat
import java.util.Date
import java.util.Locale
class Memo(): Parcelable {
// 제목
var title = ""
// 내용
var content = ""
// 날짜를 담음
var date = ""
constructor(parcel: Parcel) : this() {
title = parcel.readString()!!
content = parcel.readString()!!
date = parcel.readString()!!
}
override fun writeToParcel(parcel: Parcel, flags: Int) {
parcel.writeString(title)
parcel.writeString(content)
parcel.writeString(date)
}
override fun describeContents(): Int {
return 0
}
companion object CREATOR : Parcelable.Creator<Memo> {
override fun createFromParcel(parcel: Parcel): Memo {
return Memo(parcel)
}
override fun newArray(size: Int): Array<Memo?> {
return arrayOfNulls(size)
}
}
} | Homework_MemoApplication_LeeKyungSoo/app/src/main/java/kr/co/lion/homework_memoapplication_leekyungsoo/Memo.kt | 388303589 |
package uz.blog.uzpay
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("uz.blog.uzpay", appContext.packageName)
}
} | uz_pay_app/app/src/androidTest/java/uz/blog/uzpay/ExampleInstrumentedTest.kt | 2768054871 |
package uz.blog.uzpay
import org.junit.Test
import org.junit.Assert.*
/**
* Example local unit test, which will execute on the development machine (host).
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
class ExampleUnitTest {
@Test
fun addition_isCorrect() {
assertEquals(4, 2 + 2)
}
} | uz_pay_app/app/src/test/java/uz/blog/uzpay/ExampleUnitTest.kt | 3377090654 |
package uz.blog.uzpay.screen.repository
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import uz.blog.uzpay.screen.api.Api
import uz.blog.uzpay.screen.model.CardModel
import uz.blog.uzpay.screen.model.CategoryModel
import uz.blog.uzpay.screen.model.PaymentHistoryModel
import uz.blog.uzpay.screen.model.request.RegisterRequest
import uz.blog.uzpay.screen.model.response.AuthResponse
import uz.blog.uzpay.screen.repository.selead.DataResult
class MainRepository(private val api: Api): BaseRepository() {
suspend fun getCategories(): DataResult<List<CategoryModel>> {
return withContext(Dispatchers.IO){
try {
val response = api.getCategories()
if (response.isSuccessful){
return@withContext DataResult.Success(response.body()?.data!!)
}else {
return@withContext DataResult.Error(response.message())
}
} catch (e: Exception){
return@withContext DataResult.Error(e.localizedMessage ?: "Error not found")
}
}
}
suspend fun getCards(): DataResult<List<CardModel>> {
return withContext(Dispatchers.IO){
try {
val response = api.getCards()
if (response.isSuccessful){
return@withContext DataResult.Success(response.body()?.data!!)
}else {
return@withContext DataResult.Error(response.message())
}
} catch (e: Exception){
return@withContext DataResult.Error(e.localizedMessage ?: "Error not found")
}
}
}
suspend fun getPaymentHistory(): DataResult<List<PaymentHistoryModel>> {
return withContext(Dispatchers.IO){
try {
val response = api.getPaymentHistory()
if (response.isSuccessful){
return@withContext DataResult.Success(response.body()?.data!!)
}else {
return@withContext DataResult.Error(response.message())
}
} catch (e: Exception){
return@withContext DataResult.Error(e.localizedMessage ?: "Error not found")
}
}
}
} | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/repository/MainRepository.kt | 1090357200 |
package uz.blog.uzpay.screen.repository
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import uz.blog.uzpay.screen.api.Api
import uz.blog.uzpay.screen.model.CardModel
import uz.blog.uzpay.screen.model.ServicesModel
import uz.blog.uzpay.screen.model.request.CardRequest
import uz.blog.uzpay.screen.model.request.PaymentRequest
import uz.blog.uzpay.screen.repository.selead.DataResult
class CardRepository(private val api: Api): BaseRepository() {
suspend fun addToCard(request: CardRequest): DataResult<CardModel> {
return withContext(Dispatchers.IO){
try {
val response = api.addToCard(request)
if (response.isSuccessful){
return@withContext DataResult.Success(response.body()?.data!!)
}else {
return@withContext DataResult.Error(response.message())
}
} catch (e: Exception){
return@withContext DataResult.Error(e.localizedMessage ?: "Error not found")
}
}
}
suspend fun getPaymentList(category_id: Int): DataResult<List<ServicesModel>> {
return withContext(Dispatchers.IO){
try {
val response = api.getPaymentList(category_id)
if (response.isSuccessful){
return@withContext DataResult.Success(response.body()?.data!!)
}else {
return@withContext DataResult.Error(response.message())
}
} catch (e: Exception){
return@withContext DataResult.Error(e.localizedMessage ?: "Error not found")
}
}
}
suspend fun payment(request: PaymentRequest): DataResult<Any> {
return withContext(Dispatchers.IO){
try {
val response = api.payment(request)
if (response.isSuccessful){
return@withContext DataResult.Success(response.body()?.data!!)
}else {
return@withContext DataResult.Error(response.message())
}
} catch (e: Exception){
return@withContext DataResult.Error(e.localizedMessage ?: "Error not found")
}
}
}
suspend fun getCards(): DataResult<List<CardModel>> {
return withContext(Dispatchers.IO){
try {
val response = api.getCards()
if (response.isSuccessful){
return@withContext DataResult.Success(response.body()?.data!!)
}else {
return@withContext DataResult.Error(response.message())
}
} catch (e: Exception){
return@withContext DataResult.Error(e.localizedMessage ?: "Error not found")
}
}
}
} | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/repository/CardRepository.kt | 1463052324 |
package uz.blog.uzpay.screen.repository.selead
sealed class DataResult<T>{
data class Success<T>(val result: T): DataResult<T>()
data class Error<T>(val message: String): DataResult<T>()
}
| uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/repository/selead/DataResult.kt | 459079745 |
package uz.blog.uzpay.screen.repository
import retrofit2.Response
import uz.blog.uzpay.screen.model.response.BaseResponse
import uz.blog.uzpay.screen.repository.selead.DataResult
open class BaseRepository {
fun <T>wrapResponse(response: Response<BaseResponse<T>>): DataResult<T> {
return if (response.isSuccessful){
if (response.body()?.success == true){
DataResult.Success(response.body()?.data!!)
} else{
if (response.body()?.error_code == 1){
//DataResult.Error(response.body()?.message ?: "")
}
DataResult.Error(response.body()?.message ?: "")
}
} else {
DataResult.Error(response.message())
}
}
} | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/repository/BaseRepository.kt | 1588570271 |
package uz.blog.uzpay.screen.repository
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import uz.blog.uzpay.screen.api.Api
import uz.blog.uzpay.screen.model.request.LoginRequest
import uz.blog.uzpay.screen.model.request.RegisterRequest
import uz.blog.uzpay.screen.model.response.AuthResponse
import uz.blog.uzpay.screen.repository.selead.DataResult
class AuthRepository(private val api: Api): BaseRepository() {
suspend fun registration(registerRequest: RegisterRequest): DataResult<AuthResponse>{
return withContext(Dispatchers.IO){
try {
val response = api.registration(registerRequest)
if (response.isSuccessful){
return@withContext DataResult.Success(response.body()?.data!!)
}else {
return@withContext DataResult.Error(response.message())
}
} catch (e: Exception){
return@withContext DataResult.Error(e.localizedMessage ?: "Error not found")
}
}
}
suspend fun login(loginRequest: LoginRequest): DataResult<AuthResponse>{
return withContext(Dispatchers.IO){
try {
val response = api.login(loginRequest)
if (response.isSuccessful){
return@withContext DataResult.Success(response.body()?.data!!)
}else {
return@withContext DataResult.Error(response.message())
}
} catch (e: Exception){
return@withContext DataResult.Error(e.localizedMessage)
}
}
}
} | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/repository/AuthRepository.kt | 3902042620 |
package uz.blog.uzpay.screen.splash
import android.content.Intent
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import uz.blog.uzpay.R
import uz.blog.uzpay.databinding.ActivitySplashBinding
import uz.blog.uzpay.screen.main.MainActivity
import uz.blog.uzpay.screen.utils.PrefUtils
class SplashActivity : AppCompatActivity() {
lateinit var binding: ActivitySplashBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivitySplashBinding.inflate(layoutInflater)
setContentView(binding.root)
}
} | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/splash/SplashActivity.kt | 3133472314 |
package uz.blog.uzpay.screen
import android.app.Application
import com.orhanobut.hawk.Hawk
import dagger.hilt.android.HiltAndroidApp
@HiltAndroidApp
class MyApp: Application() {
companion object{
lateinit var app: MyApp
}
override fun onCreate() {
super.onCreate()
Hawk.init(this).build()
app = this
}
} | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/MyApp.kt | 2373251528 |
package uz.blog.uzpay.screen.di
import com.chuckerteam.chucker.api.ChuckerCollector
import com.chuckerteam.chucker.api.ChuckerInterceptor
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import okhttp3.OkHttpClient
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import uz.blog.uzpay.screen.MyApp
import uz.blog.uzpay.screen.api.Api
import uz.blog.uzpay.screen.repository.AuthRepository
import uz.blog.uzpay.screen.repository.CardRepository
import uz.blog.uzpay.screen.repository.MainRepository
import uz.blog.uzpay.screen.utils.Constants
import uz.blog.uzpay.screen.utils.PrefUtils
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
class AppModule {
@Provides
@Singleton
fun provideAuthRepository(api: Api): AuthRepository{
return AuthRepository(api)
}
@Provides
@Singleton
fun provideMainRepository(api: Api): MainRepository{
return MainRepository(api)
}
@Provides
@Singleton
fun provideCardRepository(api: Api): CardRepository{
return CardRepository(api)
}
@Provides
@Singleton
fun provideApi(retrofit: Retrofit): Api{
return retrofit.create(Api::class.java)
}
@Provides
fun provideRetrofit(): Retrofit{
return Retrofit.Builder()
.baseUrl(Constants.BASE_URL)
.client(OkHttpClient.Builder()
.addInterceptor{chain->
val request = chain.request().newBuilder()
.addHeader("Token", PrefUtils.getToken())
.addHeader("Key", Constants.DEVELOPER_KEY)
.build()
chain.proceed(request)
}
.addInterceptor(
ChuckerInterceptor.Builder(MyApp.app)
.collector(ChuckerCollector(MyApp.app))
.maxContentLength(250000L)
.redactHeaders(emptySet())
.alwaysReadResponseBody(false)
.build()
).build())
.addConverterFactory(GsonConverterFactory.create())
.build()
}
} | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/di/AppModule.kt | 383894629 |
package uz.blog.uzpay.screen.auth
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.launch
import uz.blog.uzpay.screen.model.request.LoginRequest
import uz.blog.uzpay.screen.model.request.RegisterRequest
import uz.blog.uzpay.screen.model.response.AuthResponse
import uz.blog.uzpay.screen.repository.AuthRepository
import uz.blog.uzpay.screen.repository.selead.DataResult
import uz.blog.uzpay.screen.utils.PrefUtils
import javax.inject.Inject
@HiltViewModel
class AuthViewModel @Inject constructor(private val repository: AuthRepository): ViewModel() {
private var _errorLiveData = MutableLiveData<String>()
var errorLiveData: LiveData<String> = _errorLiveData
private var _progressLiveData = MutableLiveData<Boolean>()
var progressLiveData: LiveData<Boolean> = _progressLiveData
private var _registerLiveData = MutableLiveData<AuthResponse>()
var registerLiveData: LiveData<AuthResponse> = _registerLiveData
private var _loginLiveData = MutableLiveData<AuthResponse>()
var loginLiveData: LiveData<AuthResponse> = _loginLiveData
fun sendRegister(registerRequest: RegisterRequest){
_progressLiveData.value = true
viewModelScope.launch {
when(val data = repository.registration(registerRequest)){
is DataResult.Error -> {
_errorLiveData.value = data.message
}
is DataResult.Success -> {
_registerLiveData.value = data.result!!
PrefUtils.setToken(data.result.token)
}
}
_progressLiveData.value = false
}
}
fun getLogin(loginRequest: LoginRequest){
_progressLiveData.value = true
viewModelScope.launch {
when(val data = repository.login(loginRequest)){
is DataResult.Error -> {
_errorLiveData.value = data.message
}
is DataResult.Success -> {
_loginLiveData.value = data.result!!
PrefUtils.setToken(data.result.token)
}
}
_progressLiveData.value = false
}
}
} | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/auth/AuthViewModel.kt | 2961907879 |
package uz.blog.uzpay.screen.auth
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.activityViewModels
import androidx.navigation.fragment.NavHostFragment
import androidx.navigation.fragment.findNavController
import uz.blog.uzpay.R
import uz.blog.uzpay.databinding.FragmentLoginBinding
import uz.blog.uzpay.screen.model.request.LoginRequest
import uz.blog.uzpay.screen.utils.PrefUtils
import uz.blog.uzpay.screen.utils.showMessage
class LoginFragment : Fragment() {
lateinit var binding: FragmentLoginBinding
private val viewModel: AuthViewModel by activityViewModels()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
viewModel.errorLiveData.observe(this){
requireActivity().showMessage(it)
}
viewModel.progressLiveData.observe(this){
binding.flProgress.visibility = if (it) View.VISIBLE else View.GONE
}
viewModel.loginLiveData.observe(this){
if (it.status == "accept"){
NavHostFragment.findNavController(this).navigate(R.id.action_loginFragment_to_mainFragment)
}
}
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
binding = FragmentLoginBinding.inflate(inflater)
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
binding.btnRegistration.setOnClickListener {
NavHostFragment.findNavController(this).navigate(R.id.action_loginFragment_to_registerFragment)
}
binding.btnSend.setOnClickListener {
viewModel.getLogin(LoginRequest(
binding.edPhone.text.toString(),
binding.edPassword.text.toString()
))
}
}
companion object {
@JvmStatic
fun newInstance() = LoginFragment()
}
} | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/auth/LoginFragment.kt | 1417318072 |
package uz.blog.uzpay.screen.auth
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.activityViewModels
import androidx.fragment.app.viewModels
import androidx.navigation.fragment.NavHostFragment
import uz.blog.uzpay.R
import uz.blog.uzpay.databinding.FragmentRegisterBinding
import uz.blog.uzpay.screen.model.request.RegisterRequest
import uz.blog.uzpay.screen.utils.showMessage
class RegisterFragment : Fragment() {
lateinit var binding: FragmentRegisterBinding
private val viewModel: AuthViewModel by activityViewModels()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
binding = FragmentRegisterBinding.inflate(inflater)
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
binding.btnRegistration.setOnClickListener {
NavHostFragment.findNavController(this).navigate(R.id.action_registerFragment_to_loginFragment)
}
viewModel.errorLiveData.observe(viewLifecycleOwner){
requireActivity().showMessage(it)
}
viewModel.progressLiveData.observe(viewLifecycleOwner){
binding.flProgress.visibility = if (it) View.VISIBLE else View.GONE
}
viewModel.registerLiveData.observe(viewLifecycleOwner){
requireActivity().showMessage(it.status)
NavHostFragment.findNavController(this).navigate(R.id.action_registerFragment_to_mainFragment)
}
binding.btnSend.setOnClickListener {
viewModel.sendRegister(
RegisterRequest(
binding.edName.text.toString(),
binding.edPhone.text.toString(),
binding.edPassword.text.toString()
)
)
}
}
companion object {
@JvmStatic
fun newInstance() = RegisterFragment()
}
} | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/auth/RegisterFragment.kt | 3943157517 |
package uz.blog.uzpay.screen.payment
import android.view.View
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.launch
import uz.blog.uzpay.screen.model.CardModel
import uz.blog.uzpay.screen.model.request.PaymentRequest
import uz.blog.uzpay.screen.repository.CardRepository
import uz.blog.uzpay.screen.repository.selead.DataResult
import javax.inject.Inject
@HiltViewModel
class PaymentViewModel @Inject constructor(val repository: CardRepository): ViewModel() {
private var _errorLiveData = MutableLiveData<String>()
var errorLiveData: LiveData<String> = _errorLiveData
private var _progressLiveData = MutableLiveData<Boolean>()
var progressLiveData: LiveData<Boolean> = _progressLiveData
private var _cardData = MutableLiveData<List<CardModel>>()
var cardData: LiveData<List<CardModel>> = _cardData
private var _paymentData = MutableLiveData<Any?>()
var paymentData: LiveData<Any?> = _paymentData
fun getCards(){
_progressLiveData.value = true
viewModelScope.launch {
when(val r = repository.getCards()){
is DataResult.Error -> _errorLiveData.value = r.message
is DataResult.Success -> _cardData.value = r.result!!
}
_progressLiveData.value = false
}
}
fun payment(request: PaymentRequest){
viewModelScope.launch {
when(val r = repository.payment(request)){
is DataResult.Error -> _errorLiveData.value = r.message
is DataResult.Success -> _paymentData.value = r.result
}
}
}
} | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/payment/PaymentViewModel.kt | 1670745967 |
package uz.blog.uzpay.screen.payment
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.activityViewModels
import androidx.navigation.fragment.navArgs
import androidx.viewpager2.widget.ViewPager2
import uz.blog.uzpay.R
import uz.blog.uzpay.databinding.FragmentPaymentBinding
import uz.blog.uzpay.screen.main.viewpager.ViewPagerAdapter
import uz.blog.uzpay.screen.model.request.PaymentRequest
import uz.blog.uzpay.screen.utils.PrefUtils
import uz.blog.uzpay.screen.utils.loadImage
import uz.blog.uzpay.screen.utils.showMessage
class PaymentFragment : Fragment() {
lateinit var binding: FragmentPaymentBinding
private val viewModel: PaymentViewModel by activityViewModels()
val args: PaymentFragmentArgs by navArgs()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
viewModel.errorLiveData.observe(this){
requireActivity().showMessage(it)
}
viewModel.progressLiveData.observe(this){
binding.flProgress.visibility = if (it) View.VISIBLE else View.GONE
}
viewModel.cardData.observe(this){
binding.viewPager.adapter = ViewPagerAdapter(it)
}
viewModel.paymentData.observe(this){
binding.mainContainer.visibility = View.GONE
binding.addSuccessContainer.visibility = View.VISIBLE
}
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
binding = FragmentPaymentBinding.inflate(inflater)
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
binding.edServiceName.isEnabled = false
binding.viewPager.setPageTransformer { page, position ->
val MIN_SCALE = 0.75f
val pageWidth = page.width
if (position < -1) {
page.alpha = 0f
} else if (position <= 0) {
page.alpha = 1f
page.translationX = 0f
page.scaleX = 1f
page.scaleY = 1f
} else if (position <= 1) {
page.alpha = 1 - position
page.translationX = pageWidth * -position
val scaleFactor = (MIN_SCALE
+ (1 - MIN_SCALE) * (1 - Math.abs(position)))
page.scaleX = scaleFactor
page.scaleY = scaleFactor
} else {
page.alpha = 0f
}
}
binding.edServiceName.setText(args.serviceName)
binding.imgService.loadImage(args.serviceImage.toString())
viewModel.getCards()
var card_id = 0
binding.viewPager.registerOnPageChangeCallback(object : ViewPager2.OnPageChangeCallback(){
override fun onPageSelected(position: Int) {
card_id = position
super.onPageSelected(position)
}
})
binding.btnPay.setOnClickListener {
viewModel.payment(PaymentRequest(
args.serviceId.toString().toInt(),
"12345678",
binding.edAmount.text.toString().toDouble(),
card_id
))
}
binding.btnBack.setOnClickListener {
requireActivity().onBackPressedDispatcher
}
}
companion object {
@JvmStatic
fun newInstance() = PaymentFragment()
}
} | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/payment/PaymentFragment.kt | 2706723192 |
package uz.blog.uzpay.screen.payment
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.activityViewModels
import androidx.navigation.fragment.NavHostFragment
import androidx.navigation.fragment.navArgs
import androidx.recyclerview.widget.LinearLayoutManager
import uz.blog.uzpay.databinding.FragmentPaymentListBinding
import uz.blog.uzpay.screen.add_card.AddCardViewModel
import uz.blog.uzpay.screen.model.ServicesModel
import uz.blog.uzpay.screen.utils.showMessage
import uz.blog.uzpay.screen.views.PaymentListAdapter
import uz.blog.uzpay.screen.views.PaymentListCallBack
class PaymentListFragment : Fragment(), PaymentListCallBack {
lateinit var binding: FragmentPaymentListBinding
private val viewModel: AddCardViewModel by activityViewModels()
val args: PaymentListFragmentArgs by navArgs()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
binding = FragmentPaymentListBinding.inflate(inflater)
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
binding.imgBack.setOnClickListener {
requireActivity().onBackPressed()
}
binding.recyclerPayment.layoutManager = LinearLayoutManager(requireActivity())
binding.swipe.setOnRefreshListener {
viewModel.getPaymentList(args.categoryId)
}
viewModel.errorLiveData.observe(requireActivity()){
requireActivity().showMessage(it)
}
viewModel.progressLiveData.observe(requireActivity()){
binding.swipe.isRefreshing = it
}
viewModel.servicesModelData.observe(requireActivity()){
binding.recyclerPayment.adapter = PaymentListAdapter(it, this)
}
viewModel.getPaymentList(args.categoryId)
}
companion object {
@JvmStatic
fun newInstance() = PaymentListFragment()
}
override fun openPaymentFragment(service_id: Int, service_name: String, service_image: String) {
val action = PaymentListFragmentDirections.actionPaymentListFragmentToPaymentFragment(service_id.toString(), service_name, service_image)
NavHostFragment.findNavController(this).navigate(action)
}
} | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/payment/PaymentListFragment.kt | 3804322986 |
package uz.blog.uzpay.screen.utils
import android.content.Context
import android.widget.ImageView
import android.widget.TextView
import android.widget.Toast
import com.bumptech.glide.Glide
import java.lang.StringBuilder
fun Context.showMessage(message: String){
Toast.makeText(this, message, Toast.LENGTH_LONG).show()
}
fun ImageView.loadImage(url: String){
Glide.with(this)
.load(Constants.BASE_URL + url)
.centerCrop()
.into(this)
}
fun String.setOffSetNumbers(): String{
var str = StringBuilder(this)
if(!str.isEmpty()){
str.insert(4, " ")
str.setCharAt(5, '*')
str.setCharAt(6, '*')
str.setCharAt(7, '*')
str.setCharAt(8, '*')
str.insert(9, " ")
str.setCharAt(10, '*')
str.setCharAt(11, '*')
str.setCharAt(12, '*')
str.setCharAt(13, '*')
str.insert(14, " ")
str.setCharAt(15, '*')
str.setCharAt(16, '*')
str.insert(19, " ")
return str.toString()
}
return " "
} | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/utils/Extentions.kt | 2546882449 |
package uz.blog.uzpay.screen.utils
import com.orhanobut.hawk.Hawk
import uz.blog.uzpay.screen.MyApp
object PrefUtils {
const val PREF_TOKEN = "token"
const val PREF_ACCOUNT_NUMBER = "account_number"
const val PREF_PAY_ID = "pay_id"
fun init(){
Hawk.init(MyApp.app).build()
}
fun setToken(str: String?){
Hawk.put(PREF_TOKEN, str)
}
fun getToken(): String{
return Hawk.get(PREF_TOKEN, "")
}
fun setAccountNumber(number: String?){
Hawk.put(PREF_ACCOUNT_NUMBER, number)
}
fun getAccountNUmber(): String{
return Hawk.get(PREF_ACCOUNT_NUMBER, "")
}
fun setPayId(pay_id: Int?){
Hawk.put(PREF_PAY_ID, pay_id)
}
fun getPayId(): Int{
return Hawk.get(PREF_PAY_ID, 0)
}
} | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/utils/PrefUtils.kt | 2151346012 |
package uz.blog.uzpay.screen.utils
object Constants {
const val BASE_URL = "http://openapi-uzpay.devapp.uz/"
const val DEVELOPER_KEY = "pjyHk7kPsvgASazZKyYr4NQeFRiMGp"
const val EXTRA_DATA = "extra_data"
const val EVENT_SELECT_REGION = 1
const val EVENT_SELECT_CATEGORY = 2
} | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/utils/Constants.kt | 1260732276 |
package uz.blog.uzpay.screen.add_card
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.activityViewModels
import androidx.fragment.app.viewModels
import uz.blog.uzpay.R
import uz.blog.uzpay.databinding.FragmentAddCardBinding
import uz.blog.uzpay.screen.model.request.CardRequest
import uz.blog.uzpay.screen.utils.showMessage
class AddCardFragment : Fragment() {
lateinit var binding: FragmentAddCardBinding
private val viewModel: AddCardViewModel by activityViewModels()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
viewModel.errorLiveData.observe(this){
requireActivity().showMessage(it)
}
viewModel.progressLiveData.observe(this){
binding.flProgress.visibility = if (it) View.VISIBLE else View.GONE
}
viewModel.addToCardData.observe(this){
if (it.card_number == binding.edCardNumber.text.toString()){
binding.mainCardContainer.visibility = View.GONE
binding.btnAddToCard.visibility = View.GONE
binding.addSuccessContainer.visibility = View.VISIBLE
}
}
viewModel.successAdedData.observe(this){
binding.addCardLayout.visibility = if (it) View.GONE else View.VISIBLE
}
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
binding = FragmentAddCardBinding.inflate(inflater)
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
binding.imgBack.setOnClickListener {
requireActivity().onBackPressed()
}
binding.btnAddToCard.setOnClickListener {
viewModel.addToCard(CardRequest(
binding.edCardName.text.toString(),
binding.edCardNumber.text.toString(),
binding.edCardDate.text.toString()
))
}
binding.btnBack.setOnClickListener {
requireActivity().onBackPressed()
}
}
companion object {
@JvmStatic
fun newInstance() = AddCardFragment()
}
} | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/add_card/AddCardFragment.kt | 1933754187 |
package uz.blog.uzpay.screen.add_card
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.launch
import uz.blog.uzpay.screen.model.CardModel
import uz.blog.uzpay.screen.model.ServicesModel
import uz.blog.uzpay.screen.model.request.CardRequest
import uz.blog.uzpay.screen.repository.CardRepository
import uz.blog.uzpay.screen.repository.selead.DataResult
import javax.inject.Inject
@HiltViewModel
class AddCardViewModel @Inject constructor(val repository: CardRepository): ViewModel(){
private var _errorLiveData = MutableLiveData<String>()
var errorLiveData: LiveData<String> = _errorLiveData
private var _progressLiveData = MutableLiveData<Boolean>()
var progressLiveData: LiveData<Boolean> = _progressLiveData
private var _addCardData = MutableLiveData<CardModel>()
var addToCardData: LiveData<CardModel> = _addCardData
private var _successAdedData = MutableLiveData<Boolean>()
var successAdedData: LiveData<Boolean> = _successAdedData
private var _servicesModelData = MutableLiveData<List<ServicesModel>>()
var servicesModelData: LiveData<List<ServicesModel>> = _servicesModelData
fun addToCard(request: CardRequest){
_progressLiveData.value = true
viewModelScope.launch {
when(val r = repository.addToCard(request)){
is DataResult.Error -> {
_errorLiveData.value = r.message
_successAdedData.value = false
}
is DataResult.Success -> {
_addCardData.value = r.result!!
_successAdedData.value = true
}
}
_progressLiveData.value = false
}
}
fun getPaymentList(category_id: Int){
_progressLiveData.value = true
viewModelScope.launch {
when(val r = repository.getPaymentList(category_id)){
is DataResult.Error -> {
_errorLiveData.value = r.message
}
is DataResult.Success -> {
_servicesModelData.value = r.result!!
}
}
_progressLiveData.value = false
}
}
} | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/add_card/AddCardViewModel.kt | 154951238 |
package uz.blog.uzpay.screen.model.response
data class BaseResponse<T> (
val success: Boolean,
val message: String,
val error_code: Int,
val data: T
) | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/model/response/BaseResponse.kt | 2072077085 |
package uz.blog.uzpay.screen.model.response
data class AuthResponse(
val id: Int,
val token: String,
val phone: String,
val status: String,
)
| uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/model/response/AuthResponse.kt | 1825354929 |
package uz.blog.uzpay.screen.model
data class CardModel(
val id: Int,
val app_user_id: Int,
val name: String,
val card_number: String,
val summa: Double,
val validity_period: String
)
| uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/model/CardModel.kt | 2380261737 |
package uz.blog.uzpay.screen.model
import java.io.Serializable
data class CategoryModel(
val id: Int,
val title: String,
val image: String
): Serializable
| uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/model/CategoryModel.kt | 390198720 |
package uz.blog.uzpay.screen.model
data class PaymentHistoryModel(
val id: Int,
val pay_id: Int,
val user_id: Int,
val card_id: Int,
val account_number: String,
val from_card: String,
val to_service: String,
val date: String,
val summa: Double
)
| uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/model/PaymentHistoryModel.kt | 2241492902 |
package uz.blog.uzpay.screen.model.request
data class RegisterRequest(
val fullname: String,
val phone: String,
val password: String,
)
| uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/model/request/RegisterRequest.kt | 2037263348 |
package uz.blog.uzpay.screen.model.request
data class LoginRequest(
val phone: String,
val password:String
) | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/model/request/LoginRequest.kt | 727495053 |
package uz.blog.uzpay.screen.model.request
data class PaymentRequest(
val service_id: Int,
val account_number: String,
val summa: Double,
val card_id: Int
)
| uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/model/request/PaymentRequest.kt | 1625449022 |
package uz.blog.uzpay.screen.model.request
data class CardRequest(
val name: String,
val card_number: String,
val validity_period: String,
)
| uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/model/request/CardRequest.kt | 18447084 |
package uz.blog.uzpay.screen.model
import java.io.Serializable
data class ServicesModel(
val id: Int,
val category_id: Int,
val name: String,
val image: String
): Serializable
| uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/model/ServicesModel.kt | 3147104730 |
package uz.blog.uzpay.screen.api
import okhttp3.MultipartBody
import okhttp3.RequestBody
import retrofit2.Response
import retrofit2.http.Body
import retrofit2.http.GET
import retrofit2.http.Multipart
import retrofit2.http.POST
import retrofit2.http.Part
import retrofit2.http.Path
import uz.blog.uzpay.screen.model.CardModel
import uz.blog.uzpay.screen.model.CategoryModel
import uz.blog.uzpay.screen.model.PaymentHistoryModel
import uz.blog.uzpay.screen.model.ServicesModel
import uz.blog.uzpay.screen.model.request.CardRequest
import uz.blog.uzpay.screen.model.response.BaseResponse
import uz.blog.uzpay.screen.model.request.LoginRequest
import uz.blog.uzpay.screen.model.request.PaymentRequest
import uz.blog.uzpay.screen.model.request.RegisterRequest
import uz.blog.uzpay.screen.model.response.AuthResponse
interface Api {
@POST("api/registration")
suspend fun registration(@Body request: RegisterRequest): Response<BaseResponse<AuthResponse?>>
@POST("api/login")
suspend fun login(@Body request: LoginRequest): Response<BaseResponse<AuthResponse>>
@GET("api/categories")
suspend fun getCategories(): Response<BaseResponse<List<CategoryModel>>>
@GET("api/card/list")
suspend fun getCards(): Response<BaseResponse<List<CardModel>>>
@POST("api/add/card")
suspend fun addToCard(@Body request: CardRequest): Response<BaseResponse<CardModel>>
@GET("api/payment/list")
suspend fun getPaymentHistory(): Response<BaseResponse<List<PaymentHistoryModel>>>
@GET("api/category/{category_id}/services")
suspend fun getPaymentList(@Path("category_id") id: Int): Response<BaseResponse<List<ServicesModel>>>
@POST("api/payment")
suspend fun payment(@Body request: PaymentRequest): Response<BaseResponse<Any?>>
@GET()
@Multipart
@POST("api/advertisements/add")
suspend fun addAds(
@Part mainImage: MultipartBody.Part,
@Part("category_id") category_id: RequestBody,
@Part("region_id") region_id: RequestBody,
@Part("district_id") district_id: RequestBody,
@Part("name") name: RequestBody,
@Part("comment") comment: RequestBody,
@Part("price") price: RequestBody,
@Part("address") address: RequestBody,
@Part("phone") phone: RequestBody,
): Response<BaseResponse<Boolean?>>
} | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/api/Api.kt | 257412224 |
package uz.blog.uzpay.screen.api
import android.os.Build
import com.chuckerteam.chucker.api.ChuckerCollector
import com.chuckerteam.chucker.api.ChuckerInterceptor
import com.orhanobut.hawk.BuildConfig
import okhttp3.OkHttpClient
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import uz.blog.uzpay.screen.MyApp
import uz.blog.uzpay.screen.utils.Constants
import uz.blog.uzpay.screen.utils.PrefUtils
object NetworkObject {
private var client: Api? = null
fun initClient(){
client = Retrofit.Builder()
.baseUrl(Constants.BASE_URL)
.client(OkHttpClient.Builder()
.addInterceptor{chain->
val request = chain.request().newBuilder()
.addHeader("Token", PrefUtils.getToken())
.addHeader("Key", Constants.DEVELOPER_KEY)
.build()
chain.proceed(request)
}
.addInterceptor(
ChuckerInterceptor.Builder(MyApp.app)
.collector(ChuckerCollector(MyApp.app))
.maxContentLength(250000L)
.redactHeaders(emptySet())
.alwaysReadResponseBody(false)
.build()
).build())
.addConverterFactory(GsonConverterFactory.create())
.build()
.create(Api::class.java)
}
fun getClientInstance(): Api {
if (client == null){
initClient()
}
return client!!
}
} | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/api/NetworkObject.kt | 2891048535 |
package uz.blog.uzpay.screen.main
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.launch
import uz.blog.uzpay.screen.model.CardModel
import uz.blog.uzpay.screen.model.CategoryModel
import uz.blog.uzpay.screen.model.PaymentHistoryModel
import uz.blog.uzpay.screen.repository.MainRepository
import uz.blog.uzpay.screen.repository.selead.DataResult
import javax.inject.Inject
@HiltViewModel
class MainViewModel @Inject constructor(private val repository: MainRepository): ViewModel(){
private var _errorLiveData = MutableLiveData<String>()
var errorLiveData: LiveData<String> = _errorLiveData
private var _progressLiveData = MutableLiveData<Boolean>()
var progressLiveData: LiveData<Boolean> = _progressLiveData
private var _categoryData = MutableLiveData<List<CategoryModel>>()
var categoryData: LiveData<List<CategoryModel>> = _categoryData
private var _cardData = MutableLiveData<List<CardModel>>()
var cardData: LiveData<List<CardModel>> = _cardData
private var _paymentHistoryData = MutableLiveData<List<PaymentHistoryModel>>()
var paymentHistoryData: LiveData<List<PaymentHistoryModel>> = _paymentHistoryData
fun getCategories(){
_progressLiveData.value = true
viewModelScope.launch {
when(val result = repository.getCategories()){
is DataResult.Error -> _errorLiveData.value = result.message
is DataResult.Success -> _categoryData.value = result.result!!
}
_progressLiveData.value = false
}
}
fun getCards(){
viewModelScope.launch {
when(val r = repository.getCards()){
is DataResult.Error -> _errorLiveData.value = r.message
is DataResult.Success -> _cardData.value = r.result!!
}
}
}
fun getPaymentHistoryList(){
viewModelScope.launch {
when(val r = repository.getPaymentHistory()){
is DataResult.Error -> _errorLiveData.value = r.message
is DataResult.Success -> _paymentHistoryData.value = r.result!!
}
}
}
} | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/main/MainViewModel.kt | 2113319661 |
package uz.blog.uzpay.screen.main
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.Fragment
import androidx.navigation.fragment.NavHostFragment
import uz.blog.uzpay.R
import uz.blog.uzpay.databinding.FragmentSplashBinding
import uz.blog.uzpay.screen.utils.PrefUtils
class SplashFragment : Fragment() {
lateinit var binding: FragmentSplashBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
binding = FragmentSplashBinding.inflate(layoutInflater)
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
binding.imgSplash.postDelayed({
if (PrefUtils.getToken().isEmpty()) {
NavHostFragment.findNavController(this).navigate(R.id.action_splashFragment_to_loginFragment)
} else {
NavHostFragment.findNavController(this).navigate(R.id.action_splashFragment_to_mainFragment)
}
}, 2000)
}
companion object {
@JvmStatic
fun newInstance() = SplashFragment()
}
} | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/main/SplashFragment.kt | 4129475669 |
package uz.blog.uzpay.screen.main
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import dagger.hilt.android.AndroidEntryPoint
import uz.blog.uzpay.databinding.ActivityMainBinding
@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
lateinit var binding: ActivityMainBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivityMainBinding.inflate(layoutInflater)
setContentView(binding.root)
}
} | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/main/MainActivity.kt | 728492611 |
package uz.blog.uzpay.screen.main.viewpager
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.FrameLayout
import androidx.cardview.widget.CardView
import androidx.fragment.app.Fragment
import androidx.fragment.app.FragmentActivity
import androidx.recyclerview.widget.RecyclerView
import androidx.viewpager.widget.PagerAdapter
import androidx.viewpager2.adapter.FragmentStateAdapter
import uz.blog.uzpay.databinding.ViewPagerItemLayoutBinding
import uz.blog.uzpay.screen.main.MainFragment
import uz.blog.uzpay.screen.model.CardModel
import uz.blog.uzpay.screen.utils.setOffSetNumbers
class ViewPagerAdapter(var cardList: List<CardModel>): RecyclerView.Adapter<ViewPagerAdapter.ViewPagerViewHolder>() {
inner class ViewPagerViewHolder(val binding: ViewPagerItemLayoutBinding): RecyclerView.ViewHolder(binding.root)
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewPagerViewHolder {
return ViewPagerViewHolder(ViewPagerItemLayoutBinding.inflate(LayoutInflater.from(parent.context), parent, false))
}
override fun getItemCount(): Int {
return cardList.size
}
override fun onBindViewHolder(holder: ViewPagerViewHolder, position: Int) {
val item = cardList[position]
holder.binding.tvCardNumber.text = item.card_number.setOffSetNumbers()
holder.binding.tvCardDate.text = item.validity_period
holder.binding.tvCardName.text = item.name
}
} | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/main/viewpager/ViewPagerAdapter.kt | 3917088851 |
package uz.blog.uzpay.screen.main
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.core.view.get
import androidx.fragment.app.Fragment
import androidx.fragment.app.activityViewModels
import androidx.navigation.fragment.NavHostFragment
import androidx.navigation.fragment.findNavController
import androidx.recyclerview.widget.GridLayoutManager
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import androidx.viewpager2.widget.CompositePageTransformer
import androidx.viewpager2.widget.MarginPageTransformer
import androidx.viewpager2.widget.ViewPager2
import com.orhanobut.hawk.Hawk
import uz.blog.uzpay.R
import uz.blog.uzpay.databinding.FragmentMainBinding
import uz.blog.uzpay.screen.main.viewpager.ViewPagerAdapter
import uz.blog.uzpay.screen.model.CategoryModel
import uz.blog.uzpay.screen.utils.PrefUtils
import uz.blog.uzpay.screen.utils.showMessage
import uz.blog.uzpay.screen.views.CategoryAdapter
import uz.blog.uzpay.screen.views.CategoryCallBack
import uz.blog.uzpay.screen.views.PaymentHistoryAdapter
class MainFragment : Fragment(), CategoryCallBack {
lateinit var binding: FragmentMainBinding
private val viewModel: MainViewModel by activityViewModels()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
viewModel.errorLiveData.observe(this){
requireActivity().showMessage(it)
}
viewModel.progressLiveData.observe(this){
binding.swipe.isRefreshing = it
}
viewModel.categoryData.observe(this){
binding.recycleCategory.adapter = CategoryAdapter(it, this)
}
viewModel.cardData.observe(this){
binding.viewPager.adapter = ViewPagerAdapter(it)
}
viewModel.paymentHistoryData.observe(this){
binding.recyclePayment.adapter = PaymentHistoryAdapter(it)
}
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
binding = FragmentMainBinding.inflate(inflater)
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
binding.swipe.setOnRefreshListener {
loadData()
}
// binding.viewPager.clipToPadding = false
// binding.viewPager.clipChildren = false
// binding.viewPager.offscreenPageLimit = 2
// binding.viewPager.getChildAt(0).overScrollMode = RecyclerView.OVER_SCROLL_NEVER
//
// val compositePageTransformer = CompositePageTransformer()
// compositePageTransformer.addTransformer(MarginPageTransformer(40))
// compositePageTransformer.addTransformer(ViewPager2.PageTransformer { page, position ->
// val r = 1 - Math.abs(position)
// page.scaleY = 0.95f + r * 0.05f
// })
// binding.viewPager.setPageTransformer(compositePageTransformer)
binding.viewPager.setPageTransformer { page, position ->
val MIN_SCALE = 0.75f
val pageWidth = page.width
if (position < -1) {
page.alpha = 0f
} else if (position <= 0) {
page.alpha = 1f
page.translationX = 0f
page.scaleX = 1f
page.scaleY = 1f
} else if (position <= 1) {
page.alpha = 1 - position
page.translationX = pageWidth * -position
val scaleFactor = (MIN_SCALE
+ (1 - MIN_SCALE) * (1 - Math.abs(position)))
page.scaleX = scaleFactor
page.scaleY = scaleFactor
} else {
page.alpha = 0f
}
}
binding.recycleCategory.layoutManager = GridLayoutManager(requireActivity(), 3)
binding.recyclePayment.layoutManager = LinearLayoutManager(requireActivity())
loadData()
binding.imgPayment.setOnClickListener {
findNavController().navigate(R.id.action_mainFragment_to_addCardFragment)
}
}
fun loadData(){
viewModel.getCategories()
viewModel.getCards()
viewModel.getPaymentHistoryList()
}
companion object {
@JvmStatic
fun newInstance() = MainFragment()
}
override fun sendCategoryId(categoryId: CategoryModel) {
val action = MainFragmentDirections.actionMainFragmentToPaymentListFragment(categoryId.id)
NavHostFragment.findNavController(this).navigate(action)
}
} | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/main/MainFragment.kt | 2440341459 |
package uz.blog.uzpay.screen.views
import android.view.LayoutInflater
import android.view.ViewGroup
import androidx.recyclerview.widget.RecyclerView
import uz.blog.uzpay.databinding.PaymentListItemLayoutBinding
import uz.blog.uzpay.screen.model.ServicesModel
import uz.blog.uzpay.screen.utils.loadImage
interface PaymentListCallBack{
fun openPaymentFragment(service_id: Int, service_name: String, service_image: String)
}
class PaymentListAdapter(val items: List<ServicesModel>, val callback: PaymentListCallBack): RecyclerView.Adapter<PaymentListAdapter.ItemHolder>() {
inner class ItemHolder(val binding: PaymentListItemLayoutBinding): RecyclerView.ViewHolder(binding.root)
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ItemHolder {
return ItemHolder(PaymentListItemLayoutBinding.inflate(LayoutInflater.from(parent.context), parent, false))
}
override fun getItemCount(): Int {
return items.count()
}
override fun onBindViewHolder(holder: ItemHolder, position: Int) {
val item = items[position]
holder.binding.tvTitle.text = item.name
holder.binding.imgCompany.loadImage(item.image)
holder.itemView.setOnClickListener {
callback.openPaymentFragment(item.id, item.name, item.image)
}
}
} | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/views/PaymentListAdapter.kt | 1485279389 |
package uz.blog.uzpay.screen.views
import android.view.LayoutInflater
import android.view.ViewGroup
import androidx.recyclerview.widget.RecyclerView
import uz.blog.uzpay.databinding.CategoryItmLayoutBinding
import uz.blog.uzpay.databinding.PaymentHistoryItemLayoutBinding
import uz.blog.uzpay.screen.model.CategoryModel
import uz.blog.uzpay.screen.model.PaymentHistoryModel
import uz.blog.uzpay.screen.utils.loadImage
import uz.blog.uzpay.screen.utils.setOffSetNumbers
class PaymentHistoryAdapter(val items: List<PaymentHistoryModel>): RecyclerView.Adapter<PaymentHistoryAdapter.ItemHolder>() {
inner class ItemHolder(val binding: PaymentHistoryItemLayoutBinding): RecyclerView.ViewHolder(binding.root)
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ItemHolder {
return ItemHolder(PaymentHistoryItemLayoutBinding.inflate(LayoutInflater.from(parent.context), parent, false))
}
override fun getItemCount(): Int {
return items.count()
}
override fun onBindViewHolder(holder: ItemHolder, position: Int) {
val item = items[position]
holder.binding.tvCardNumber.text = item.from_card.setOffSetNumbers()
holder.binding.tvDate.text = item.date
holder.binding.tvSumma.text = item.summa.toString() + " UZS"
}
} | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/views/PaymentHistoryAdapter.kt | 3202443173 |
package uz.blog.uzpay.screen.views
import android.view.LayoutInflater
import android.view.ViewGroup
import androidx.recyclerview.widget.RecyclerView
import uz.blog.uzpay.databinding.CategoryItmLayoutBinding
import uz.blog.uzpay.screen.model.CategoryModel
import uz.blog.uzpay.screen.utils.loadImage
interface CategoryCallBack{
fun sendCategoryId(categoryId: CategoryModel)
}
class CategoryAdapter(val items: List<CategoryModel>, var categoryId: CategoryCallBack): RecyclerView.Adapter<CategoryAdapter.ItemHolder>() {
inner class ItemHolder(val binding: CategoryItmLayoutBinding): RecyclerView.ViewHolder(binding.root)
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ItemHolder {
return ItemHolder(CategoryItmLayoutBinding.inflate(LayoutInflater.from(parent.context), parent, false))
}
override fun getItemCount(): Int {
return items.count()
}
override fun onBindViewHolder(holder: ItemHolder, position: Int) {
val item = items[position]
holder.binding.tvCategoryTitle.text = item.title
holder.binding.imgCategory.loadImage(item.image)
holder.itemView.setOnClickListener {
categoryId.sendCategoryId(item)
}
}
} | uz_pay_app/app/src/main/java/uz/blog/uzpay/screen/views/CategoryAdapter.kt | 4144896908 |
package kiradk.client
import io.ktor.client.engine.*
import io.ktor.client.request.*
import io.ktor.network.selector.*
import io.ktor.network.sockets.*
import io.ktor.util.*
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
internal fun newKiraDKEngine(config: KiraDKClientConfig): KiraDKClientEngine {
return when(config.mode) {
KiraClientMode.Default -> KiraDKClientEngine(config)
KiraClientMode.SingleConnection -> SingleConnectionEngine(config)
}
}
public open class KiraDKClientEngine(
override val config: KiraDKClientConfig
) : HttpClientEngineBase("KiraDK") {
@OptIn(InternalAPI::class)
override suspend fun execute(data: HttpRequestData): HttpResponseData {
// TODO: WS, ...
return executeHttp(data)
}
private suspend fun executeHttp(data: HttpRequestData): HttpResponseData {
val socket = createSocket(data)
TODO()
}
public open suspend fun createSocket(request: HttpRequestData): Socket {
return when (request.url.protocol.name) {
"http" -> aSocket(SelectorManager(this.dispatcher)).tcp().connect(request.url.host, request.url.port)
"https" -> TODO()
else -> throw UnsupportedOperationException("Unsupported protocol ${request.url.protocol}")
}
}
}
internal class SingleConnectionEngine(
config: KiraDKClientConfig
) : KiraDKClientEngine(config) {
@Volatile
private var socket: Socket? = null
private val lock = Mutex()
override suspend fun createSocket(request: HttpRequestData): Socket {
socket?.let { return it }
return lock.withLock {
socket?.let { return it }
val new = super.createSocket(request)
this.socket = new
new
}
}
}
| kiradk/kiradk-ktor-client/src/main/kotlin/KiraDKClientEngine.kt | 1902819864 |
package kiradk.client.utils
public class MutableRange<T : Comparable<T>>(
public var start: T,
public var end: T,
) {
override fun toString(): String {
return "MutableRange(start=$start, end=$end)"
}
}
public class MutableIntRange(
public var start: Int,
public var end: Int
) {
override fun toString(): String {
return "MutableIntRange(start=$start, end=$end)"
}
}
| kiradk/kiradk-ktor-client/src/main/kotlin/utils/MutableRange.kt | 3756370963 |
package kiradk.client.utils
public fun <T> defaultSorter(value: T): T = value
| kiradk/kiradk-ktor-client/src/main/kotlin/utils/utils.kt | 1129961173 |
package kiradk.client.utils
@RequiresOptIn("KiraDK Experimental API", level = RequiresOptIn.Level.WARNING)
public annotation class KiraDKExperimental
| kiradk/kiradk-ktor-client/src/main/kotlin/utils/Annontations.kt | 740712947 |
package kiradk.client.utils
import kotlin.reflect.KProperty
@KiraDKExperimental
public object LazyTODO {
public operator fun <T> getValue(thisRef: Any?, property: KProperty<*>): T = TODO()
public operator fun <T> setValue(thisRef: Any?, property: KProperty<*>, value: T): Unit = TODO()
}
| kiradk/kiradk-ktor-client/src/main/kotlin/utils/LazyTODO.kt | 1276910040 |
package kiradk.client.tls
import io.ktor.network.tls.*
import io.ktor.utils.io.*
import io.ktor.utils.io.core.*
import kotlin.experimental.and
private const val MAX_TLS_FRAME_SIZE = 0x4800
internal suspend fun ByteReadChannel.readTLSRecord(): TLSRecord {
val type = TLSRecordType.byCode(readByte().toInt() and 0xff)
val version = readTLSVersion()
val length = readShortCompatible() and 0xffff
if (length > MAX_TLS_FRAME_SIZE) throw Exception("Illegal TLS frame size: $length")
val packet = readPacket(length)
return TLSRecord(type, version, packet)
}
internal fun ByteReadPacket.readTLSHandshake(): TLSHandShake {
return TLSHandShake().apply {
val typeAndVersion = readInt()
type = TLSHandshakeType.byCode(typeAndVersion ushr 24)
val length = typeAndVersion and 0xffffff
packet = buildPacket {
writeFully(readBytes(length))
}
}
}
internal fun ByteReadPacket.readTLSServerHello(): TLSServerHello {
val version = readTLSVersion()
val random = ByteArray(32)
readFully(random)
val sessionIdLength = readByte().toInt() and 0xff
if (sessionIdLength > 32) {
throw TLSException("sessionId length limit of 32 bytes exceeded: $sessionIdLength specified")
}
val sessionId = ByteArray(32)
readFully(sessionId, 0, sessionIdLength)
val suite = readShort()
val compressionMethod = readByte().toShort() and 0xff
if (compressionMethod.toInt() != 0) {
throw TLSException(
"Unsupported TLS compression method $compressionMethod (only null 0 compression method is supported)"
)
}
if (remaining.toInt() == 0) return TLSServerHello(
version,
random,
sessionId,
suite,
compressionMethod
)
// handle extensions
val extensionSize = readShort().toInt() and 0xffff
if (remaining.toInt() != extensionSize) {
throw TLSException("Invalid extensions size: requested $extensionSize, available $remaining")
}
val extensions = mutableListOf<TLSExtensionRecord>()
while (remaining > 0) {
val type = readShort().toInt() and 0xffff
val length = readShort().toInt() and 0xffff
extensions += TLSExtensionRecord(
TLSExtensionType.byCode(type),
length,
buildPacket { writeFully(readBytes(length)) }
)
}
return TLSServerHello(version, random, sessionId, suite, compressionMethod, extensions)
}
internal suspend fun ByteReadChannel.readTLSVersion(): TLSVersion =
TLSVersion.byCode(readShortCompatible() and 0xffff)
private fun ByteReadPacket.readTLSVersion(): TLSVersion =
TLSVersion.byCode(readShort().toInt() and 0xffff)
internal fun ByteReadPacket.readTripleByteLength(): Int = (readByte().toInt() and 0xff shl 16) or
(readShort().toInt() and 0xffff)
internal suspend fun ByteReadChannel.readShortCompatible(): Int {
val first = readByte().toInt() and 0xff
val second = readByte().toInt() and 0xff
return (first shl 8) + second
}
| kiradk/kiradk-ktor-client/src/main/kotlin/tls/Parser.kt | 1422545759 |
package kiradk.client.tls
import java.security.SecureRandom
internal fun SecureRandom.generateClientSeed(): ByteArray {
val seed = ByteArray(32)
nextBytes(seed)
return seed.also {
val unixTime = (System.currentTimeMillis() / 1000L)
it[0] = (unixTime shr 24).toByte()
it[1] = (unixTime shr 16).toByte()
it[2] = (unixTime shr 8).toByte()
it[3] = (unixTime shr 0).toByte()
}
}
| kiradk/kiradk-ktor-client/src/main/kotlin/tls/utils.kt | 2600969359 |
package kiradk.client.tls
public enum class TLSExtensionType(public val code: Int) {
ServerName(0x0000),
MaxFragmentLength(0x0001),
ClientCertificateURL(0x0002),
TrustedCAKeys(0x0003),
TruncatedHMAC(0x0004),
StatusRequest(0x0005),
UserMapping(0x0006),
ClientAuthz(0x0007),
ServerAuthz(0x0008),
CertificateType(0x0009),
SupportedGroups(0x000a),
ECPointsFormat(0x000b),
SRP(0x000c),
SignatureAlgorithms(0x000d),
UseSRTP(0x000e),
Heartbeat(0x000f),
ALPN(0x0010),
StatusRequestV2(0x0011),
SignedCertificateTimestamp(0x0012),
ClientCertificateType(0x0013),
ServerCertificateType(0x0014),
Padding(0x0015),
EncryptThenMAC(0x0016),
ExtendedMasterSecret(0x0017),
TokenBinding(0x0018),
CachedInfo(0x0019),
TLS_LTS(0x001a),
CompressCertificate(0x001b),
RecordSizeLimit(0x001c),
PWDProtect(0x001d),
PWDClear(0x001e),
PasswordSalt(0x001f),
TicketPinning(0x0020),
TLSCertWithExternPsk(0x0021),
DelegatedCredential(0x0022),
SessionTicket(0x0023),
TLMSP(0x0024),
TLMSPProxying(0x0025),
TLMSPDelegate(0x0026),
SupportedEKTCiphers(0x0027),
PreSharedKey(0x0029),
EarlyData(0x002a),
SupportedVersions(0x002b),
Cookie(0x002c),
PSKKeyExchangeModes(0x002d),
CertificateAuthorities(0x002f),
OIDFilters(0x0030),
PostHandshakeAuth(0x0031),
SignatureAlgorithmsCert(0x0032),
// KeyShareOld(0x0033),
TransparencyInfo(0x0034),
// ConnectionID(0x0036),
ConnectionSessionID(0x0037),
ExternalSessionId(0x0038),
QuicTransportParameters(0x0039),
TicketRequest(0x003a),
DnssecChain(0x003b),
RenegotiationInfo(0xff01);
public companion object {
public fun byCode(code: Int): TLSExtensionType {
return entries.find { it.code == code } ?: throw IllegalArgumentException("Unknown extension type: $code")
}
}
}
| kiradk/kiradk-ktor-client/src/main/kotlin/tls/TLSExtensionType.kt | 1116082134 |
package kiradk.client.tls
import io.ktor.network.tls.*
import io.ktor.utils.io.core.*
internal fun BytePacketBuilder.writeTLSHandshakeType(type: TLSHandshakeType, length: Int) {
if (length > 0xffffff) throw TLSException("TLS handshake size limit exceeded: $length")
val v = (type.code shl 24) or length
writeInt(v)
}
internal fun BytePacketBuilder.writeTLSClientHello(
version: TLSVersion,
suites: List<CipherSuite>,
extensions: List<TLSExtensionRecord>,
compression: Int,
random: ByteArray,
sessionId: ByteArray,
) {
writeShort(version.code.toShort())
writeFully(random)
val sessionIdLength = sessionId.size
if (sessionIdLength < 0 || sessionIdLength > 0xff || sessionIdLength > sessionId.size) {
throw TLSException("Illegal sessionIdLength")
}
writeByte(sessionIdLength.toByte())
writeFully(sessionId, 0, sessionIdLength)
writeShort((suites.size * 2).toShort())
for (suite in suites) {
writeShort(suite.code)
}
// compression is always null, TODO
writeByte(1)
writeByte(0)
writeShort(extensions.sumOf { it.length }.toShort())
for (extension in extensions) {
writePacket(extension.packet)
}
}
| kiradk/kiradk-ktor-client/src/main/kotlin/tls/Render.kt | 2700460704 |
package kiradk.client.tls
import io.ktor.network.tls.*
import io.ktor.network.tls.extensions.*
import io.ktor.utils.io.*
import io.ktor.utils.io.core.*
public class TLSRecord(
public val type: TLSRecordType = TLSRecordType.Handshake,
public val version: TLSVersion = TLSVersion.TLS12,
public val packet: ByteReadPacket = ByteReadPacket.Empty,
)
public suspend fun ByteWriteChannel.writeTlsRecord(record: TLSRecord) {
writeByte(record.type.code.toByte())
writeByte((record.version.code shr 8).toByte())
writeByte(record.version.code.toByte())
writeShort(record.packet.remaining.toShort())
writePacket(record.packet)
flush()
}
public class TLSHandShake {
public var type: TLSHandshakeType = TLSHandshakeType.HelloRequest
public var packet: ByteReadPacket = ByteReadPacket.Empty
}
public class TLSExtensionRecord(
public val type: TLSExtensionType,
public val length: Int,
public val packet: ByteReadPacket,
)
internal class TLSServerHello(
val version: TLSVersion,
val serverSeed: ByteArray,
val sessionId: ByteArray,
suite: Short,
val compressionMethod: Short,
val extensions: List<TLSExtensionRecord> = emptyList()
) {
val cipherSuite: CipherSuite = TODO()
val hashAndSignAlgorithms: List<HashAndSign>
init {
val algorithms = mutableListOf<HashAndSign>()
extensions.forEach {
when (it.type) {
TLSExtensionType.SignatureAlgorithms -> {
// algorithms += it.packet.parseSignatureAlgorithms()
}
else -> {
}
}
}
hashAndSignAlgorithms = algorithms
}
}
| kiradk/kiradk-ktor-client/src/main/kotlin/tls/TLSRecord.kt | 3839587949 |
package kiradk.client.tls
import java.io.IOException
public class TLSException(message: String, cause: Throwable? = null) : IOException(message, cause)
| kiradk/kiradk-ktor-client/src/main/kotlin/tls/TLSException.kt | 764438148 |
package kiradk.client.tls
import io.ktor.network.tls.*
import io.ktor.network.util.*
import io.ktor.utils.io.core.*
import java.security.MessageDigest
internal fun Digest(): Digest = Digest(BytePacketBuilder())
@JvmInline
internal value class Digest(val state: BytePacketBuilder) : Closeable {
fun update(packet: ByteReadPacket) = synchronized(state) {
if (packet.isEmpty) return
state.writePacket(packet.copy())
}
fun doHash(hashName: String): ByteArray = synchronized(state) {
state.preview { handshakes: ByteReadPacket ->
val digest = MessageDigest.getInstance(hashName)!!
val buffer = DefaultByteBufferPool.borrow()
try {
while (!handshakes.isEmpty) {
val rc = handshakes.readAvailable(buffer)
if (rc == -1) break
buffer.flip()
digest.update(buffer)
buffer.clear()
}
return@preview digest.digest()
} finally {
DefaultByteBufferPool.recycle(buffer)
}
}
}
override fun close() {
state.release()
}
}
internal operator fun Digest.plusAssign(record: TLSHandShake) {
check(record.type != TLSHandshakeType.HelloRequest)
update(
buildPacket {
writeTLSHandshakeType(record.type, record.packet.remaining.toInt())
if (record.packet.remaining > 0) writePacket(record.packet.copy())
}
)
}
| kiradk/kiradk-ktor-client/src/main/kotlin/tls/Digest.kt | 382388492 |
package kiradk.client.tls
internal interface TLSCipher {
fun encrypt(record: TLSRecord): TLSRecord
fun decrypt(record: TLSRecord): TLSRecord
}
| kiradk/kiradk-ktor-client/src/main/kotlin/tls/TLSCipher.kt | 3858915840 |
package kiradk.client.tls
import io.ktor.network.sockets.*
import io.ktor.network.tls.*
import io.ktor.utils.io.*
import io.ktor.utils.io.core.*
import kiradk.client.utils.LazyTODO
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.ObsoleteCoroutinesApi
import kotlinx.coroutines.channels.*
import kotlin.coroutines.CoroutineContext
// io.ktor.network.tls.TLSClientHandshake
internal class TLSClientHandshake(
socketReadChannel: ByteReadChannel,
socketWriteChannel: ByteWriteChannel,
val clientHelloID: ClientHelloID,
override val coroutineContext: CoroutineContext
) : CoroutineScope {
private val helloSpec = clientHelloID.specFactory()
private val digest = Digest()
private val clientSeed: ByteArray = helloSpec.clientRandFactory(helloSpec.secureRandom)
@Volatile
private lateinit var serverHello: TLSServerHello
private val cipher: TLSCipher by LazyTODO
@OptIn(ExperimentalCoroutinesApi::class)
val input: ReceiveChannel<TLSRecord> = produce {
var useCipher = false
try {
loop@ while (true) {
val rawRecord = socketReadChannel.readTLSRecord()
val record = if (useCipher) cipher.decrypt(rawRecord) else rawRecord
val packet = record.packet
when (record.type) {
TLSRecordType.Alert -> {
val level = TLSAlertLevel.byCode(packet.readByte().toInt())
val code = TLSAlertType.byCode(packet.readByte().toInt())
if (code == TLSAlertType.CloseNotify) return@produce
val cause = TLSException("Received alert during handshake. Level: $level, code: $code")
channel.close(cause)
return@produce
}
TLSRecordType.ChangeCipherSpec -> {
check(!useCipher)
val flag = packet.readByte()
if (flag != 1.toByte()) {
throw TLSException("Expected flag: 1, received $flag in ChangeCipherSpec")
}
useCipher = true
continue@loop
}
TLSRecordType.Handshake -> {}
TLSRecordType.ApplicationData -> {}
}
channel.send(TLSRecord(record.type, packet = packet))
}
} catch (cause: ClosedReceiveChannelException) {
channel.close()
} catch (cause: Throwable) {
channel.close()
} finally {
output.close()
}
}
@OptIn(ObsoleteCoroutinesApi::class)
val output: SendChannel<TLSRecord> = actor {
var useCipher = false
try {
for (rawRecord in channel) {
try {
val record = if (useCipher) cipher.encrypt(rawRecord) else rawRecord
if (rawRecord.type == TLSRecordType.ChangeCipherSpec) useCipher = true
socketWriteChannel.writeTlsRecord(record)
} catch (cause: Throwable) {
channel.close(cause)
}
}
} finally {
socketWriteChannel.writeTlsRecord(
TLSRecord(
TLSRecordType.Alert,
packet = buildPacket {
writeByte(TLSAlertLevel.WARNING.code.toByte())
writeByte(TLSAlertType.CloseNotify.code.toByte())
}
)
)
socketWriteChannel.close()
}
}
@OptIn(ExperimentalCoroutinesApi::class)
private val handshakes: ReceiveChannel<TLSHandShake> = produce {
while (true) {
val record = input.receive()
if (record.type != TLSRecordType.Handshake) {
record.packet.release()
throw TLSException("TLS handshake expected, got ${record.type}")
}
val packet = record.packet
while (packet.isNotEmpty) {
val handshake = packet.readTLSHandshake()
if (handshake.type == TLSHandshakeType.HelloRequest) continue
if (handshake.type != TLSHandshakeType.Finished) {
digest += handshake
}
channel.send(handshake)
if (handshake.type == TLSHandshakeType.Finished) {
packet.release()
return@produce
}
}
}
}
suspend fun negotiate() {
digest.use {
sendClientHello()
serverHello = receiveServerHello()
verifyHello(serverHello)
}
}
private suspend fun sendClientHello() {
sendHandshakeRecord(TLSHandshakeType.ClientHello) {
writeTLSClientHello(
TLSVersion.TLS12,
helloSpec.cipherSuites,
helloSpec.extensions,
0,
clientSeed,
ByteArray(32)
)
}
}
private suspend fun sendHandshakeRecord(handshakeType: TLSHandshakeType, block: BytePacketBuilder.() -> Unit) {
val handshakeBody = buildPacket(block)
val recordBody = buildPacket {
writeTLSHandshakeType(handshakeType, handshakeBody.remaining.toInt())
writePacket(handshakeBody)
}
digest.update(recordBody)
val element = TLSRecord(TLSRecordType.Handshake, packet = recordBody)
try {
output.send(element)
} catch (cause: Throwable) {
element.packet.release()
throw cause
}
}
private suspend fun receiveServerHello(): TLSServerHello {
val handshake = handshakes.receive()
check(handshake.type == TLSHandshakeType.ServerHello) {
("Expected TLS handshake ServerHello but got ${handshake.type}")
}
return handshake.packet.readTLSServerHello()
}
private suspend fun verifyHello(serverHello: TLSServerHello) {
val suit = serverHello.cipherSuite
// TODO check suit
}
} | kiradk/kiradk-ktor-client/src/main/kotlin/tls/TLSClientHandshake.kt | 2959989271 |
package kiradk.client.tls
import kiradk.client.utils.LazyTODO
public class ClientHelloID(
public val name: String,
public val version: String,
public val specFactory: () -> ClientHelloSpec
) {
public companion object {
public val Default: ClientHelloID by LazyTODO
}
} | kiradk/kiradk-ktor-client/src/main/kotlin/tls/ClientHelloID.kt | 2915974781 |
package kiradk.client.tls
import io.ktor.network.tls.*
import java.security.SecureRandom
public class ClientHelloSpec(
public val cipherSuites: List<CipherSuite>,
public val compressionMethods: ByteArray,
public val extensions: List<TLSExtensionRecord>,
public val secureRandom: SecureRandom = SecureRandom(),
public val clientRandFactory: ((SecureRandom) -> ByteArray) = { it.generateClientSeed() }
)
| kiradk/kiradk-ktor-client/src/main/kotlin/tls/ClientHelloSpec.kt | 1774343775 |
package kiradk.client.tls
import io.ktor.network.sockets.*
import io.ktor.utils.io.*
@Suppress("Deprecation")
internal class TLSSocket(
private val socket: Socket
) : Socket by socket {
override fun attachForReading(channel: ByteChannel): WriterJob {
TODO("Not yet implemented")
}
override fun attachForWriting(channel: ByteChannel): ReaderJob {
TODO("Not yet implemented")
}
override fun dispose() {
socket.dispose()
}
}
| kiradk/kiradk-ktor-client/src/main/kotlin/tls/TLSSocket.kt | 2002917642 |
package kiradk.client
import io.ktor.client.engine.*
public object KiraDK : HttpClientEngineFactory<KiraDKClientConfig> {
override fun create(block: KiraDKClientConfig.() -> Unit): HttpClientEngine {
return newKiraDKEngine(KiraDKClientConfig().apply(block))
}
}
| kiradk/kiradk-ktor-client/src/main/kotlin/KiraDK.kt | 290474774 |
package kiradk.client
import io.ktor.client.engine.*
import io.ktor.http.*
import kiradk.client.utils.defaultSorter
public class KiraDKClientConfig : HttpClientEngineConfig() {
public var proxyUrl: Url? = null
public var mode: KiraClientMode = KiraClientMode.Default
public var headerSorter: (List<String>) -> List<String> = ::defaultSorter
}
public enum class KiraClientMode {
Default,
SingleConnection
}
| kiradk/kiradk-ktor-client/src/main/kotlin/KiraDKClientConfig.kt | 2476428439 |
package kiradk.client.http
import io.ktor.http.*
import io.ktor.utils.io.*
import io.ktor.utils.io.core.*
import kiradk.client.utils.MutableIntRange
public suspend fun parseResponse(input: ByteReadChannel): Response? {
val range = MutableIntRange(0, 0)
try {
val line = input.readUTF8Line() ?: return null
TODO()
} catch (cause: Throwable) {
// todo
throw cause
}
}
private fun parseVersion(text: String, range: MutableIntRange): HttpProtocolVersion {
skipSpaces(text, range)
check(range.start < range.end) { "Failed to parse version: $text" }
TODO()
}
private fun parseStatus(text: String, range: MutableIntRange): HttpStatusCode {
TODO()
}
private suspend fun parseHeaders(
input: ByteReadChannel
): Headers = TODO()
private fun skipSpaces(text: CharSequence, range: MutableIntRange) {
var idx = range.start
val end = range.end
if (idx >= end || !text[idx].isWhitespace()) return
idx++
while (idx < end) {
if (!text[idx].isWhitespace()) break
idx++
}
range.start = idx
} | kiradk/kiradk-ktor-client/src/main/kotlin/http/HttpParser.kt | 3429149047 |
package kiradk.client.http
import io.ktor.http.*
public abstract class HttpMessage internal constructor(
public val headers: Headers,
public val body: ByteArray,
)
public class Response internal constructor(
public val version: HttpProtocolVersion,
public val statusCode: HttpStatusCode,
headers: Headers,
body: ByteArray,
) : HttpMessage(headers, body)
| kiradk/kiradk-ktor-client/src/main/kotlin/http/HttpMessage.kt | 2222011018 |
public class HttpRequest {
} | kiradk/http/src/main/kotlin/HttpRequest.kt | 2509384691 |
public class HttpResponse(
public val method:Method,
public val version:Version,
public val resource:Resource,
public val headers:HashMap<String, String>,
public val msgBody:String
)
public enum class Method{
POST,
GET,
Uninitialized
}
public enum class Version{
V1_1,
Uninitialized
}
public data class Resource(
val path: Path
){
public data class Path(
val string: String
)
} | kiradk/http/src/main/kotlin/HttpResponse.kt | 826831694 |
package dev.keikem.catzapp
import android.app.Application
import android.content.Context
import androidx.room.Room
import com.google.gson.Gson
import dagger.hilt.android.HiltAndroidApp
import dev.keikem.catzapp.data.api.CatsApi
import dev.keikem.catzapp.data.api.DogsApi
import dev.keikem.catzapp.data.local.Database
import okhttp3.OkHttpClient
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import retrofit2.create
import java.util.concurrent.TimeUnit
//Класс, репрезентирующий само приложение
@HiltAndroidApp
class App : Application() | CatzApp/app/src/main/java/dev/keikem/catzapp/App.kt | 2791628135 |
package dev.keikem.catzapp.di
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import dev.keikem.catzapp.data.api.CatsApi
import dev.keikem.catzapp.data.api.DogsApi
import dev.keikem.catzapp.data.local.dao.CatDao
import dev.keikem.catzapp.data.local.dao.DogDao
import dev.keikem.catzapp.data.repository.CatRepository
import dev.keikem.catzapp.data.repository.DogRepository
import dev.keikem.catzapp.domain.usecases.GimmeACatLocalUseCase
import dev.keikem.catzapp.domain.usecases.GimmeACatRemoteUseCase
import dev.keikem.catzapp.domain.usecases.GimmeADogLocalUseCase
import dev.keikem.catzapp.domain.usecases.GimmeADogRemoteUseCase
@Module
@InstallIn(SingletonComponent::class)
class AppModule {
@Provides
fun provideDogRepository(dao: DogDao, api: DogsApi): DogRepository = DogRepository(dao, api)
@Provides
fun provideCatRepository(dao: CatDao, api: CatsApi): CatRepository = CatRepository(dao, api)
@Provides
fun provideLocalCatUseCase(repository: CatRepository): GimmeACatLocalUseCase =
GimmeACatLocalUseCase(repository)
@Provides
fun provideRemoteCatUseCase(repository: CatRepository): GimmeACatRemoteUseCase =
GimmeACatRemoteUseCase(repository)
@Provides
fun provideLocalDogUseCase(repository: DogRepository): GimmeADogLocalUseCase =
GimmeADogLocalUseCase(repository)
@Provides
fun provideRemoteDogUseCase(repository: DogRepository): GimmeADogRemoteUseCase =
GimmeADogRemoteUseCase(repository)
}
| CatzApp/app/src/main/java/dev/keikem/catzapp/di/AppModule.kt | 1627949297 |
package dev.keikem.catzapp.di
import com.google.gson.Gson
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import dev.keikem.catzapp.data.api.CatsApi
import dev.keikem.catzapp.data.api.DogsApi
import okhttp3.OkHttpClient
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import retrofit2.create
import java.util.concurrent.TimeUnit
import javax.inject.Named
@Module
@InstallIn(SingletonComponent::class)
class NetworkModule {
//Base provides
@Provides
fun provideGson(): Gson = Gson()
@Provides
fun provideOkHttpClient(): OkHttpClient =
OkHttpClient.Builder().connectTimeout(10L, TimeUnit.SECONDS).build()
//retrofit provides
@Provides
@Named("CatRetrofit")
fun provideCatRetrofit(okHttpClient: OkHttpClient, gson: Gson): Retrofit =
Retrofit.Builder().baseUrl("https://api.thecatapi.com/")
.client(okHttpClient)
.addConverterFactory(
GsonConverterFactory.create(gson)
).build()
@Provides
@Named("DogRetrofit")
fun provideDogRetrofit(okHttpClient: OkHttpClient, gson: Gson): Retrofit =
Retrofit.Builder().baseUrl("https://dog.ceo/")
.client(okHttpClient)
.addConverterFactory(
GsonConverterFactory.create(gson)
).build()
//Api provides
@Provides
fun provideCatApi(@Named("CatRetrofit") retrofit: Retrofit): CatsApi = retrofit.create()
@Provides
fun provideDogApi(@Named("DogRetrofit") retrofit: Retrofit): DogsApi =
retrofit.create(DogsApi::class.java)
} | CatzApp/app/src/main/java/dev/keikem/catzapp/di/NetworkModule.kt | 3860501166 |
package dev.keikem.catzapp.di
import android.content.Context
import androidx.room.Room
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.android.qualifiers.ApplicationContext
import dagger.hilt.components.SingletonComponent
import dev.keikem.catzapp.data.local.Database
import dev.keikem.catzapp.data.local.dao.CatDao
import dev.keikem.catzapp.data.local.dao.DogDao
@Module
@InstallIn(SingletonComponent::class)
class DatabaseModule {
@Provides
fun provideDatabase(@ApplicationContext context: Context): Database = Room.databaseBuilder(
context,
Database::class.java,
"database.db"
).build()
@Provides
fun provideCatDao(database: Database): CatDao = database.catDao()
@Provides
fun provideDogDao(database: Database): DogDao = database.dogDao()
} | CatzApp/app/src/main/java/dev/keikem/catzapp/di/DatabaseModule.kt | 3296922819 |
package dev.keikem.catzapp.screens.activity
import androidx.appcompat.app.AppCompatActivity
import dagger.hilt.android.AndroidEntryPoint
import dev.keikem.catzapp.R
/* Единственная активити в приложений
* Что это нам дает:
* 1) Удобство работы с несколькими экранами, не будет путаницы в жизненом цикле
* 2) Можно делать красивые переходы между экранами, несколько активностей такого не позволяют
*/
@AndroidEntryPoint
class RootActivity : AppCompatActivity(R.layout.activity_root) | CatzApp/app/src/main/java/dev/keikem/catzapp/screens/activity/RootActivity.kt | 850117046 |
package dev.keikem.catzapp.screens.fragment.cat
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import dagger.hilt.android.lifecycle.HiltViewModel
import dev.keikem.catzapp.data.repository.CatRepository
import dev.keikem.catzapp.domain.usecases.GimmeACatLocalUseCase
import dev.keikem.catzapp.domain.usecases.GimmeACatRemoteUseCase
import dev.keikem.catzapp.domain.usecases.GimmeADogRemoteUseCase
import kotlinx.coroutines.CoroutineExceptionHandler
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import javax.inject.Inject
@HiltViewModel
class CatViewModel @Inject constructor(
private val localUseCase: GimmeACatLocalUseCase,
private val remoteUseCase: GimmeACatRemoteUseCase
) : ViewModel() {
private var _state: MutableLiveData<State?> = MutableLiveData(null) // flow
val state: LiveData<State?> = _state
//UDF = Undirectonal data flow
sealed class State {
data class ImageLoaded(val url: String) : State()
data class Error(val message: String) : State()
}
init {
loadFromDatabase()
}
private fun loadFromDatabase() {
Thread {
val im = localUseCase.gimme()
im?.let { image -> _state.postValue(State.ImageLoaded(url = image)) }
}.start()
}
/* fun loadFromRemoteThread() {
//Thread - отдельный поток выполнения, он отвечает за то где будет выполнятся операция
Thread {
Thread.sleep(5000)
_imageUrl.postValue(gimmeACatRemoteUseCase.gimme())
}.start()
} */
fun loadFromRemote() {
val coroutineExceptionHandler = CoroutineExceptionHandler { coroutineContext, throwable ->
_state.postValue(
State.Error(
message = throwable.message ?: "Не удалось получить картинку"
)
)
}
viewModelScope.launch(Dispatchers.IO + coroutineExceptionHandler) {
remoteUseCase.gimme()?.let { _state.postValue(State.ImageLoaded(url = it)) }
?: _state.postValue(State.Error(message = "Значение не может быть пустым"))
}
}
} | CatzApp/app/src/main/java/dev/keikem/catzapp/screens/fragment/cat/CatViewModel.kt | 1140054660 |
package dev.keikem.catzapp.screens.fragment.cat
import android.os.Bundle
import android.view.View
import android.widget.Button
import android.widget.ImageView
import android.widget.TextView
import androidx.core.view.isVisible
import androidx.fragment.app.Fragment
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleEventObserver
import androidx.lifecycle.LifecycleOwner
import androidx.lifecycle.ViewModelProvider
import androidx.navigation.Navigation
import coil.load
import com.google.android.material.progressindicator.CircularProgressIndicator
import dagger.hilt.android.AndroidEntryPoint
import dev.keikem.catzapp.R
//Фрагмент, показывающии котика
@AndroidEntryPoint
class CatFragment : Fragment(R.layout.fragment_cat), LifecycleEventObserver {
private var viewModel: CatViewModel? = null
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
lifecycle.addObserver(this)
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
val image = view.findViewById<ImageView>(R.id.image)
val button = view.findViewById<Button>(R.id.button)
val buttonLoad = view.findViewById<Button>(R.id.buttonLoad)
val progress = view.findViewById<CircularProgressIndicator>(R.id.progress)
val errorText = view.findViewById<TextView>(R.id.errorText)
viewModel?.state?.observe(viewLifecycleOwner) { state ->
when (state) {
is CatViewModel.State.ImageLoaded -> {
image.load(state.url)
progress.isVisible = false
errorText.isVisible = false
}
is CatViewModel.State.Error -> {
progress.isVisible = false
errorText.isVisible = true
errorText.text = state.message
}
else -> Unit
}
}
buttonLoad.setOnClickListener {
progress.isVisible = true
viewModel?.loadFromRemote()
}
button.setOnClickListener {
Navigation.findNavController(requireActivity(), R.id.appNavHostFragment)
.navigate(R.id.toNextFragment)
}
}
override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
when (event) {
Lifecycle.Event.ON_CREATE -> {
viewModel = ViewModelProvider(this)[CatViewModel::class.java]
}
else -> Unit
}
}
} | CatzApp/app/src/main/java/dev/keikem/catzapp/screens/fragment/cat/CatFragment.kt | 2480113758 |
package dev.keikem.catzapp.screens.fragment.dog
import android.os.Bundle
import android.view.View
import android.widget.Button
import android.widget.ImageView
import androidx.core.view.isVisible
import androidx.fragment.app.Fragment
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleEventObserver
import androidx.lifecycle.LifecycleOwner
import androidx.lifecycle.ViewModelProvider
import androidx.navigation.Navigation
import coil.load
import com.google.android.material.progressindicator.CircularProgressIndicator
import dagger.hilt.android.AndroidEntryPoint
import dev.keikem.catzapp.R
@AndroidEntryPoint
class DogFragment : Fragment(R.layout.fragment_cat), LifecycleEventObserver {
private var viewModel: DogViewModel? = null
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
lifecycle.addObserver(this)
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
val image = view.findViewById<ImageView>(R.id.image)
val button = view.findViewById<Button>(R.id.button)
val buttonLoad = view.findViewById<Button>(R.id.buttonLoad)
val progress = view.findViewById<CircularProgressIndicator>(R.id.progress)
viewModel?.imageUrl?.observe(viewLifecycleOwner) { url ->
if (url.isNotEmpty()) {
image.load(url)
progress.isVisible = false
}
}
buttonLoad.text = "Load Dog"
button.text = "Navigate Back"
buttonLoad.setOnClickListener {
progress.isVisible = true
viewModel?.loadFromRemote()
}
button.setOnClickListener {
Navigation.findNavController(requireActivity(), R.id.appNavHostFragment).popBackStack()
}
}
override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
when (event) {
Lifecycle.Event.ON_CREATE -> {
viewModel = ViewModelProvider(this)[DogViewModel::class.java]
}
else -> Unit
}
}
} | CatzApp/app/src/main/java/dev/keikem/catzapp/screens/fragment/dog/DogFragment.kt | 1832471634 |
package dev.keikem.catzapp.screens.fragment.dog
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import dagger.hilt.android.lifecycle.HiltViewModel
import dev.keikem.catzapp.data.repository.DogRepository
import dev.keikem.catzapp.domain.usecases.GimmeACatLocalUseCase
import dev.keikem.catzapp.domain.usecases.GimmeACatRemoteUseCase
import dev.keikem.catzapp.domain.usecases.GimmeADogLocalUseCase
import dev.keikem.catzapp.domain.usecases.GimmeADogRemoteUseCase
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import javax.inject.Inject
@HiltViewModel
class DogViewModel @Inject constructor(
private val localUseCase: GimmeADogLocalUseCase,
private val remoteUseCase: GimmeADogRemoteUseCase
) : ViewModel() {
private var _imageUrl: MutableLiveData<String> = MutableLiveData("")
val imageUrl: LiveData<String> = _imageUrl
init {
loadFromLocal()
}
private fun loadFromLocal() {
Thread {
val im = localUseCase.gimme()
im?.let { image -> _imageUrl.postValue(image) }
}.start()
}
/* fun loadFromRemote() {
//Thread - отдельный поток выполнения, он отвечает за то где будет выполнятся операция
Thread {
Thread.sleep(5000)
_imageUrl.postValue(gimmeADogRemoteUseCase.gimme())
}.start()
} */
fun loadFromRemote() {
viewModelScope.launch(Dispatchers.IO) {
//delay(5000)
_imageUrl.postValue(remoteUseCase.gimme())
}
}
} | CatzApp/app/src/main/java/dev/keikem/catzapp/screens/fragment/dog/DogViewModel.kt | 3494432103 |
package dev.keikem.catzapp.data.repository
import dev.keikem.catzapp.data.api.CatsApi
import dev.keikem.catzapp.data.local.dao.CatDao
import dev.keikem.catzapp.data.local.entity.LocalCat
import javax.inject.Inject
class CatRepository @Inject constructor(private val dao: CatDao, private val api: CatsApi) {
suspend fun loadFromRemote(): String? = api.getCat()?.get(0)?.url
/* var urlConnection: HttpsURLConnection? = null
val imageUrl: String
try {
val url = URL("https://api.thecatapi.com/v1/images/search")
urlConnection = url.openConnection() as HttpsURLConnection
urlConnection.connect()
val stream = urlConnection.inputStream
val reader = BufferedReader(InputStreamReader(stream))
val result = reader.lines().collect(Collectors.joining())
val typeAlias = object : TypeToken<List<RemoteCat>>() {}.type
val convertedResult: List<RemoteCat> = Gson().fromJson(result, typeAlias)
imageUrl = convertedResult[0].url
} finally {
urlConnection?.disconnect()
}
return imageUrl*/
fun loadFromLocal(): String? = dao.get()?.imageUrl
fun saveToLocal(cat: LocalCat) {
dao.set(cat)
}
} | CatzApp/app/src/main/java/dev/keikem/catzapp/data/repository/CatRepository.kt | 2845131660 |
package dev.keikem.catzapp.data.repository
import dev.keikem.catzapp.data.api.DogsApi
import dev.keikem.catzapp.data.local.dao.DogDao
import dev.keikem.catzapp.data.local.entity.LocalDog
import javax.inject.Inject
class DogRepository @Inject constructor(private val dao: DogDao, private val api: DogsApi) {
suspend fun loadFromRemote(): String? = api.getDog()?.message
/* var urlConnection: HttpsURLConnection? = null
val imageUrl: String
try {
val url = URL("https://dog.ceo/api/breeds/image/random")
urlConnection = url.openConnection() as HttpsURLConnection
urlConnection.connect()
val stream = urlConnection.inputStream
val reader = BufferedReader(InputStreamReader(stream))
val result = reader.lines().collect(Collectors.joining())
val typeAlias = object : TypeToken<RemoteDog>() {}.type
val convertedResult: RemoteDog = Gson().fromJson(result, typeAlias)
imageUrl = convertedResult.message
} finally {
urlConnection?.disconnect()
}
return imageUrl
} */
fun loadFromLocal(): String? = dao.get()?.imageUrl
fun saveToLocal(dog: LocalDog) {
dao.set(dog)
}
} | CatzApp/app/src/main/java/dev/keikem/catzapp/data/repository/DogRepository.kt | 528285224 |
package dev.keikem.catzapp.data.local.entity
import androidx.room.ColumnInfo
import androidx.room.Entity
import androidx.room.PrimaryKey
//Сущность таблицы, репрезентующей способ хранения котиков
@Entity(tableName = "cat_table")
data class LocalCat(
@PrimaryKey val id: String,
@ColumnInfo("image_url") val imageUrl: String
) | CatzApp/app/src/main/java/dev/keikem/catzapp/data/local/entity/LocalCat.kt | 227298692 |
package dev.keikem.catzapp.data.local.entity
import androidx.room.ColumnInfo
import androidx.room.Entity
import androidx.room.PrimaryKey
@Entity(tableName = "dog_table")
data class LocalDog(
@PrimaryKey val id: String,
@ColumnInfo("image_url") val imageUrl: String
) | CatzApp/app/src/main/java/dev/keikem/catzapp/data/local/entity/LocalDog.kt | 1577018057 |
package dev.keikem.catzapp.data.local.dao
import androidx.room.Dao
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query
import dev.keikem.catzapp.data.local.entity.LocalDog
@Dao
interface DogDao {
@Query("SELECT * from dog_table")
fun get() : LocalDog?
@Insert(onConflict = OnConflictStrategy.REPLACE)
fun set(cat: LocalDog)
} | CatzApp/app/src/main/java/dev/keikem/catzapp/data/local/dao/DogDao.kt | 4027597489 |
package dev.keikem.catzapp.data.local.dao
import androidx.room.Dao
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query
import dev.keikem.catzapp.data.local.entity.LocalCat
//Сущность для взаимодействия с таблицей БД котиков
@Dao
interface CatDao {
@Query("SELECT * from cat_table")
fun get() : LocalCat?
@Insert(onConflict = OnConflictStrategy.REPLACE)
fun set(cat: LocalCat)
} | CatzApp/app/src/main/java/dev/keikem/catzapp/data/local/dao/CatDao.kt | 2161663375 |
package dev.keikem.catzapp.data.local
import androidx.room.AutoMigration
import androidx.room.Database
import androidx.room.RoomDatabase
import dev.keikem.catzapp.data.local.dao.CatDao
import dev.keikem.catzapp.data.local.dao.DogDao
import dev.keikem.catzapp.data.local.entity.LocalCat
import dev.keikem.catzapp.data.local.entity.LocalDog
//Обьект базы данных
@Database(
entities = [
LocalCat::class,
LocalDog::class,
],
//После добавления новой сущности - увеличиваем версию
version = 1,
autoMigrations = [
//После добавления новой сущности - увеличиваем версию и добавляем авто миграции по образцу ниже
// AutoMigration(1, 2)
],
exportSchema = true
)
abstract class Database : RoomDatabase() {
abstract fun catDao(): CatDao
abstract fun dogDao(): DogDao
}
| CatzApp/app/src/main/java/dev/keikem/catzapp/data/local/Database.kt | 2878639426 |
package dev.keikem.catzapp.data.api
import dev.keikem.catzapp.data.remote.RemoteCat
import retrofit2.http.GET
interface CatsApi {
@GET("/v1/images/search")
suspend fun getCat(): List<RemoteCat>?
} | CatzApp/app/src/main/java/dev/keikem/catzapp/data/api/CatsApi.kt | 3456940919 |
package dev.keikem.catzapp.data.api
import dev.keikem.catzapp.data.remote.RemoteDog
import retrofit2.Call
import retrofit2.http.GET
interface DogsApi {
@GET("/api/breeds/image/random")
suspend fun getDog(): RemoteDog?
} | CatzApp/app/src/main/java/dev/keikem/catzapp/data/api/DogsApi.kt | 4220380678 |
package dev.keikem.catzapp.data.remote
data class RemoteDog(
val message: String,
val status: String
) | CatzApp/app/src/main/java/dev/keikem/catzapp/data/remote/RemoteDog.kt | 991927151 |
package dev.keikem.catzapp.data.remote
// Обьект, в который мы преобразовываем полученную нами информацию о котиках
data class RemoteCat(
val id: String,
val url: String,
val width: Int,
val height: Int
) | CatzApp/app/src/main/java/dev/keikem/catzapp/data/remote/RemoteCat.kt | 2828892922 |
package dev.keikem.catzapp.domain.usecases
import dev.keikem.catzapp.data.local.entity.LocalCat
import dev.keikem.catzapp.data.repository.CatRepository
import javax.inject.Inject
//Класс, репрезентующии получение данных с бека и преобразование в то с чем мы работаем, а также сохранение в базу
class GimmeACatRemoteUseCase @Inject constructor(private val repository: CatRepository) {
suspend fun gimme(): String? {
val catUrl = repository.loadFromRemote()
catUrl?.let { repository.saveToLocal(LocalCat(id = "1", imageUrl = it)) }
return catUrl
}
} | CatzApp/app/src/main/java/dev/keikem/catzapp/domain/usecases/GimmeACatRemoteUseCase.kt | 3143147928 |
package dev.keikem.catzapp.domain.usecases
import dev.keikem.catzapp.data.repository.CatRepository
import javax.inject.Inject
//Класс, репрезентующии получение данных с базы и преобразование в то с чем мы работаем
class GimmeACatLocalUseCase @Inject constructor(private val repository: CatRepository) {
fun gimme(): String? = repository.loadFromLocal()
} | CatzApp/app/src/main/java/dev/keikem/catzapp/domain/usecases/GimmeACatLocalUseCase.kt | 2418806312 |
package dev.keikem.catzapp.domain.usecases
import dev.keikem.catzapp.data.repository.DogRepository
import javax.inject.Inject
class GimmeADogLocalUseCase @Inject constructor(private val repository: DogRepository) {
fun gimme(): String? = repository.loadFromLocal()
} | CatzApp/app/src/main/java/dev/keikem/catzapp/domain/usecases/GimmeADogLocalUseCase.kt | 2122979140 |
package dev.keikem.catzapp.domain.usecases
import dev.keikem.catzapp.data.local.entity.LocalDog
import dev.keikem.catzapp.data.repository.DogRepository
import javax.inject.Inject
class GimmeADogRemoteUseCase @Inject constructor(private val repository: DogRepository) {
suspend fun gimme(): String? {
val dogUrl = repository.loadFromRemote()
dogUrl?.let { repository.saveToLocal(LocalDog(id = "1", imageUrl = it)) }
return dogUrl
}
} | CatzApp/app/src/main/java/dev/keikem/catzapp/domain/usecases/GimmeADogRemoteUseCase.kt | 3621955013 |
package ir.ehsan.asmrcarousel
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("ir.ehsan.asmrcarousel", appContext.packageName)
}
} | Blurred-Carousel/app/src/androidTest/java/ir/ehsan/asmrcarousel/ExampleInstrumentedTest.kt | 2758300721 |
package ir.ehsan.asmrcarousel
import org.junit.Test
import org.junit.Assert.*
/**
* Example local unit test, which will execute on the development machine (host).
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
class ExampleUnitTest {
@Test
fun addition_isCorrect() {
assertEquals(4, 2 + 2)
}
} | Blurred-Carousel/app/src/test/java/ir/ehsan/asmrcarousel/ExampleUnitTest.kt | 2119377113 |
package ir.ehsan.asmrcarousel.ui.theme
import androidx.compose.ui.graphics.Color
val Purple80 = Color(0xFFD0BCFF)
val PurpleGrey80 = Color(0xFFCCC2DC)
val Pink80 = Color(0xFFEFB8C8)
val Purple40 = Color(0xFF6650a4)
val PurpleGrey40 = Color(0xFF625b71)
val Pink40 = Color(0xFF7D5260) | Blurred-Carousel/app/src/main/java/ir/ehsan/asmrcarousel/ui/theme/Color.kt | 2625702972 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.