content
stringlengths 0
3.9M
| path
stringlengths 4
242
| contentHash
stringlengths 1
10
|
|---|---|---|
package com.ujizin.camposer
import androidx.compose.runtime.MutableState
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.ui.test.junit4.ComposeContentTestRule
import androidx.test.ext.junit.runners.AndroidJUnit4
import com.ujizin.camposer.state.ImplementationMode
import org.junit.Assert.assertEquals
import org.junit.Test
import org.junit.runner.RunWith
@RunWith(AndroidJUnit4::class)
internal class ImplementationModeTest : CameraTest() {
private lateinit var implementationMode: MutableState<ImplementationMode>
@Test
fun test_implementationMode() = with(composeTestRule) {
initImplementationModeCamera(ImplementationMode.Performance)
assertEquals(cameraState.implementationMode, ImplementationMode.Performance)
implementationMode.value = ImplementationMode.Compatible
runOnIdle {
assertEquals(cameraState.implementationMode, ImplementationMode.Compatible)
}
}
private fun ComposeContentTestRule.initImplementationModeCamera(
initialValue: ImplementationMode
) = initCameraState { state ->
implementationMode = remember { mutableStateOf(initialValue) }
CameraPreview(
cameraState = state,
implementationMode = implementationMode.value,
)
}
} | camerajetpackcompose/camposer/src/androidTest/java/com/ujizin/camposer/ImplementationModeTest.kt | 3768088178 |
package com.ujizin.camposer
import androidx.camera.core.ImageProxy
import androidx.compose.ui.test.junit4.ComposeContentTestRule
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.filters.LargeTest
import com.ujizin.camposer.state.ImageAnalyzer
import com.ujizin.camposer.state.rememberImageAnalyzer
import org.junit.Assert.assertEquals
import org.junit.Test
import org.junit.runner.RunWith
@RunWith(AndroidJUnit4::class)
@LargeTest
internal class ImageAnalyzerTest : CameraTest() {
private lateinit var imageAnalyzer: ImageAnalyzer
@Test
fun test_imageAnalyzer() = with(composeTestRule) {
var isAnalyzeCalled = false
initImageAnalyzerCamera {
isAnalyzeCalled = true
it.close()
}
waitUntil(ANALYZER_TIME_OUT) { isAnalyzeCalled }
runOnIdle {
if (cameraState.isImageAnalysisSupported) {
assertEquals(true, cameraState.isImageAnalysisEnabled)
assertEquals(true, isAnalyzeCalled)
}
}
}
@Test
fun test_imageAnalyzerDisabled() = with(composeTestRule) {
var isAnalyzeCalled = false
initImageAnalyzerCamera(isImageAnalyzeEnabled = false) { isAnalyzeCalled = true }
runOnIdle {
if (cameraState.isImageAnalysisSupported) {
assertEquals(false, cameraState.isImageAnalysisEnabled)
assertEquals(false, isAnalyzeCalled)
}
}
}
@Test
fun test_imageAnalysisSupported() = with(composeTestRule) {
var expectImageAnalysisSupported: Boolean? = null
initImageAnalyzerCamera(isImageAnalyzeEnabled = true)
expectImageAnalysisSupported = cameraState.isImageAnalysisSupported()
runOnIdle {
assertEquals(expectImageAnalysisSupported, cameraState.isImageAnalysisSupported)
assertEquals(expectImageAnalysisSupported, cameraState.isImageAnalysisEnabled)
}
}
private fun ComposeContentTestRule.initImageAnalyzerCamera(
isImageAnalyzeEnabled: Boolean = true,
analyze: (ImageProxy) -> Unit = {},
) = initCameraState { state ->
imageAnalyzer = state.rememberImageAnalyzer(analyze = analyze)
CameraPreview(
cameraState = state,
imageAnalyzer = imageAnalyzer,
isImageAnalysisEnabled = isImageAnalyzeEnabled
)
}
private companion object {
private const val ANALYZER_TIME_OUT = 2_000L
}
}
| camerajetpackcompose/camposer/src/androidTest/java/com/ujizin/camposer/ImageAnalyzerTest.kt | 456781036 |
package com.ujizin.camposer
import androidx.compose.runtime.MutableState
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.ui.test.junit4.ComposeContentTestRule
import androidx.test.ext.junit.runners.AndroidJUnit4
import com.ujizin.camposer.state.ScaleType
import org.junit.Assert.assertEquals
import org.junit.Test
import org.junit.runner.RunWith
@RunWith(AndroidJUnit4::class)
internal class ScaleTypeTest : CameraTest() {
private lateinit var scaleType: MutableState<ScaleType>
@Test
fun test_scaleType() = with(composeTestRule) {
initScaleTypeCamera()
ScaleType.values().forEach { scale ->
scaleType.value = scale
runOnIdle { assertEquals(cameraState.scaleType, scaleType.value) }
}
}
private fun ComposeContentTestRule.initScaleTypeCamera(
initialValue: ScaleType = ScaleType.FitStart
) = initCameraState { state ->
scaleType = remember { mutableStateOf(initialValue) }
CameraPreview(
cameraState = state,
scaleType = scaleType.value,
)
}
} | camerajetpackcompose/camposer/src/androidTest/java/com/ujizin/camposer/ScaleTypeTest.kt | 467690160 |
package com.ujizin.camposer
import androidx.camera.view.CameraController
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.size
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.MutableState
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.testTag
import androidx.compose.ui.test.assertIsDisplayed
import androidx.compose.ui.test.junit4.ComposeContentTestRule
import androidx.compose.ui.test.onNodeWithTag
import androidx.compose.ui.test.performClick
import androidx.compose.ui.unit.dp
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.filters.LargeTest
import kotlinx.coroutines.delay
import org.junit.Assert.assertEquals
import org.junit.Test
import org.junit.runner.RunWith
@RunWith(AndroidJUnit4::class)
@LargeTest
internal class FocusOnTapTest : CameraTest() {
private lateinit var isFocusTappedState: MutableState<Boolean>
private val isCameraXFocused: Boolean
get() = when (cameraState.controller.tapToFocusState.value) {
CameraController.TAP_TO_FOCUS_STARTED, CameraController.TAP_TO_FOCUS_FOCUSED -> true
else -> false
}
@Test
fun test_focusOnTap(): Unit = with(composeTestRule) {
initFocusCamera(initialValue = true)
if (!cameraState.isFocusOnTapSupported) return
onNodeWithTag(FOCUS_TEST_TAG).performClick()
runOnIdle {
assertEquals(true, isCameraXFocused)
assertEquals(true, isFocusTappedState.value)
}
onNodeWithTag(FOCUS_TAP_CONTENT_TAG).assertIsDisplayed()
}
@Test
fun test_focusOnTapDisable() = with(composeTestRule) {
initFocusCamera(initialValue = false)
if (!cameraState.isFocusOnTapSupported) return
onNodeWithTag(FOCUS_TEST_TAG).performClick()
runOnIdle {
assertEquals(false, isFocusTappedState.value)
assertEquals(false, isCameraXFocused)
}
}
@Test
fun test_onFocusCallbackOnComplete() = with(composeTestRule) {
var completed = false
initFocusCamera(initialValue = true) { onComplete ->
delay(FOCUS_DELAY)
onComplete()
completed = true
}
if (!cameraState.isFocusOnTapSupported) return
onNodeWithTag(FOCUS_TEST_TAG).performClick()
onNodeWithTag(FOCUS_TAP_CONTENT_TAG).assertIsDisplayed()
runOnIdle {
assertEquals(true, isCameraXFocused)
assertEquals(true, isFocusTappedState.value)
}
waitUntil(FOCUS_ON_COMPLETE_DELAY) { completed }
onNodeWithTag(FOCUS_TAP_CONTENT_TAG).assertDoesNotExist()
}
private fun ComposeContentTestRule.initFocusCamera(
initialValue: Boolean = true,
onFocus: suspend (onComplete: () -> Unit) -> Unit = { onComplete ->
delay(DEFAULT_FOCUS_DELAY)
onComplete()
}
) = initCameraState { state ->
val isFocusOnTapEnabled by remember { mutableStateOf(initialValue) }
isFocusTappedState = remember { mutableStateOf(false) }
CameraPreview(
modifier = Modifier.testTag(FOCUS_TEST_TAG),
cameraState = state,
isFocusOnTapEnabled = isFocusOnTapEnabled,
focusTapContent = {
Box(
modifier = Modifier
.testTag(FOCUS_TAP_CONTENT_TAG)
.background(Color.Red)
.size(64.dp)
)
LaunchedEffect(Unit) { isFocusTappedState.value = true }
},
onFocus = onFocus
)
}
private companion object {
private const val FOCUS_TEST_TAG = "focus_test_tag"
private const val FOCUS_TAP_CONTENT_TAG = "focus_tap_content_tag"
private const val DEFAULT_FOCUS_DELAY = 300L
private const val FOCUS_DELAY = 500L
private const val FOCUS_ON_COMPLETE_DELAY = 2_500L
}
}
| camerajetpackcompose/camposer/src/androidTest/java/com/ujizin/camposer/FocusOnTapTest.kt | 4074098107 |
package com.ujizin.camposer
import androidx.compose.runtime.Composable
import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.State
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleEventObserver
/**
* Observe lifecycle as state composable.
*
* Based on https://stackoverflow.com/a/69061897/11903815.
* */
@Composable
internal fun Lifecycle.observeAsState(): State<Lifecycle.Event> {
val state = remember { mutableStateOf(Lifecycle.Event.ON_ANY) }
DisposableEffect(this) {
val observer = LifecycleEventObserver { _, event ->
state.value = event
}
[email protected](observer)
onDispose {
[email protected](observer)
}
}
return state
} | camerajetpackcompose/camposer/src/main/java/com/ujizin/camposer/LifecycleState.kt | 2724584690 |
package com.ujizin.camposer
import android.annotation.SuppressLint
import android.graphics.Bitmap
import android.view.ViewGroup
import androidx.camera.view.PreviewView
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberUpdatedState
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.platform.LocalLifecycleOwner
import androidx.compose.ui.viewinterop.AndroidView
import androidx.lifecycle.Lifecycle
import com.ujizin.camposer.extensions.clamped
import com.ujizin.camposer.extensions.onCameraTouchEvent
import com.ujizin.camposer.focus.FocusTap
import com.ujizin.camposer.focus.SquareCornerFocus
import com.ujizin.camposer.state.CamSelector
import com.ujizin.camposer.state.CameraState
import com.ujizin.camposer.state.CaptureMode
import com.ujizin.camposer.state.FlashMode
import com.ujizin.camposer.state.ImageAnalyzer
import com.ujizin.camposer.state.ImageCaptureMode
import com.ujizin.camposer.state.ImageTargetSize
import com.ujizin.camposer.state.ImplementationMode
import com.ujizin.camposer.state.ScaleType
import com.ujizin.camposer.state.rememberCameraState
import kotlinx.coroutines.delay
import androidx.camera.core.CameraSelector as CameraXSelector
/**
* Creates a Camera Preview's composable.
*
* @param cameraState camera state hold some states and camera's controller, it can be useful to given action like [CameraState.takePicture]
* @param camSelector camera selector to be added, default is back
* @param captureMode camera capture mode, default is image
* @param imageCaptureMode camera image capture mode, default is minimum latency for better performance
* @param imageCaptureTargetSize suggested target size for image camera capture, default is camera's preferred size
* @param flashMode flash mode to be added, default is off
* @param scaleType scale type to be added, default is fill center
* @param enableTorch enable torch from camera, default is false.
* @param exposureCompensation camera exposure compensation to be added
* @param zoomRatio zoom ratio to be added, default is 1.0
* @param imageAnalyzer image analyzer from camera, see [ImageAnalyzer]
* @param implementationMode implementation mode to be added, default is performance
* @param isImageAnalysisEnabled enable or disable image analysis
* @param isFocusOnTapEnabled turn on feature focus on tap if true
* @param isPinchToZoomEnabled turn on feature pinch to zoom if true
* @param onPreviewStreamChanged dispatch when preview is switching to front or back
* @param onSwitchToFront composable preview when change camera to front and it's not been streaming yet
* @param onSwitchToBack composable preview when change camera to back and it's not been streaming yet
* @param onZoomRatioChanged dispatch when zoom is changed by pinch to zoom
* @param focusTapContent content of focus tap, default is [SquareCornerFocus]
* @param onFocus callback to use when on focus tap is triggered, call onComplete to [focusTapContent] gone.
* @param content content composable within of camera preview.
* @see ImageAnalyzer
* @see CameraState
* */
@Composable
public fun CameraPreview(
modifier: Modifier = Modifier,
cameraState: CameraState = rememberCameraState(),
camSelector: CamSelector = cameraState.camSelector,
captureMode: CaptureMode = cameraState.captureMode,
imageCaptureMode: ImageCaptureMode = cameraState.imageCaptureMode,
imageCaptureTargetSize: ImageTargetSize? = cameraState.imageCaptureTargetSize,
flashMode: FlashMode = cameraState.flashMode,
scaleType: ScaleType = cameraState.scaleType,
enableTorch: Boolean = cameraState.enableTorch,
exposureCompensation: Int = cameraState.initialExposure,
zoomRatio: Float = 1F,
imageAnalyzer: ImageAnalyzer? = null,
implementationMode: ImplementationMode = cameraState.implementationMode,
isImageAnalysisEnabled: Boolean = cameraState.isImageAnalysisEnabled,
isFocusOnTapEnabled: Boolean = cameraState.isFocusOnTapEnabled,
isPinchToZoomEnabled: Boolean = cameraState.isZoomSupported,
onPreviewStreamChanged: () -> Unit = {},
onSwitchToFront: @Composable (Bitmap) -> Unit = {},
onSwitchToBack: @Composable (Bitmap) -> Unit = {},
onFocus: suspend (onComplete: () -> Unit) -> Unit = { onComplete ->
delay(1000L)
onComplete()
},
onZoomRatioChanged: (Float) -> Unit = {},
focusTapContent: @Composable () -> Unit = { SquareCornerFocus() },
content: @Composable () -> Unit = {},
) {
CameraPreviewImpl(
modifier = modifier,
cameraState = cameraState,
camSelector = camSelector,
captureMode = captureMode,
exposureCompensation = exposureCompensation,
imageCaptureMode = imageCaptureMode,
imageCaptureTargetSize = imageCaptureTargetSize,
flashMode = flashMode,
scaleType = scaleType,
enableTorch = enableTorch,
zoomRatio = zoomRatio,
imageAnalyzer = imageAnalyzer,
isImageAnalysisEnabled = isImageAnalysisEnabled,
implementationMode = implementationMode,
isFocusOnTapEnabled = isFocusOnTapEnabled,
isPinchToZoomEnabled = isPinchToZoomEnabled,
onZoomRatioChanged = onZoomRatioChanged,
focusTapContent = focusTapContent,
onFocus = onFocus,
onPreviewStreamChanged = onPreviewStreamChanged,
onSwipeToFront = onSwitchToFront,
onSwipeToBack = onSwitchToBack,
content = content
)
}
@SuppressLint("RestrictedApi")
@Composable
internal fun CameraPreviewImpl(
modifier: Modifier,
cameraState: CameraState,
camSelector: CamSelector,
captureMode: CaptureMode,
imageCaptureMode: ImageCaptureMode,
imageCaptureTargetSize: ImageTargetSize?,
flashMode: FlashMode,
scaleType: ScaleType,
enableTorch: Boolean,
zoomRatio: Float,
implementationMode: ImplementationMode,
imageAnalyzer: ImageAnalyzer?,
exposureCompensation: Int,
isImageAnalysisEnabled: Boolean,
isFocusOnTapEnabled: Boolean,
isPinchToZoomEnabled: Boolean,
onZoomRatioChanged: (Float) -> Unit,
onPreviewStreamChanged: () -> Unit,
onFocus: suspend (() -> Unit) -> Unit,
onSwipeToFront: @Composable (Bitmap) -> Unit,
onSwipeToBack: @Composable (Bitmap) -> Unit,
focusTapContent: @Composable () -> Unit,
content: @Composable () -> Unit
) {
val lifecycleOwner = LocalLifecycleOwner.current
val lifecycleEvent by lifecycleOwner.lifecycle.observeAsState()
val cameraIsInitialized by rememberUpdatedState(cameraState.isInitialized)
var tapOffset by remember { mutableStateOf(Offset.Zero) }
val isCameraIdle by rememberUpdatedState(!cameraState.isStreaming)
var latestBitmap by remember { mutableStateOf<Bitmap?>(null) }
AndroidView(modifier = modifier, factory = { context ->
PreviewView(context).apply {
layoutParams = ViewGroup.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT
)
controller = cameraState.controller.apply {
bindToLifecycle(lifecycleOwner)
}
previewStreamState.observe(lifecycleOwner) { state ->
cameraState.isStreaming = state == PreviewView.StreamState.STREAMING
}
}
}, update = { previewView ->
if (cameraIsInitialized) {
with(previewView) {
this.scaleType = scaleType.type
this.implementationMode = implementationMode.value
onCameraTouchEvent(
onTap = { if (isFocusOnTapEnabled) tapOffset = it },
onScaleChanged = {
if (isPinchToZoomEnabled) {
val zoom = zoomRatio.clamped(it).coerceIn(
minimumValue = cameraState.minZoom,
maximumValue = cameraState.maxZoom
)
onZoomRatioChanged(zoom)
}
}
)
latestBitmap = when {
lifecycleEvent == Lifecycle.Event.ON_STOP -> null
!isCameraIdle && camSelector != cameraState.camSelector -> bitmap
else -> latestBitmap
}
cameraState.update(
camSelector = camSelector,
captureMode = captureMode,
imageCaptureTargetSize = imageCaptureTargetSize,
scaleType = scaleType,
isImageAnalysisEnabled = isImageAnalysisEnabled,
imageAnalyzer = imageAnalyzer,
implementationMode = implementationMode,
isFocusOnTapEnabled = isFocusOnTapEnabled,
flashMode = flashMode,
enableTorch = enableTorch,
zoomRatio = zoomRatio,
imageCaptureMode = imageCaptureMode,
meteringPoint = meteringPointFactory.createPoint(x, y),
exposureCompensation = exposureCompensation,
)
}
}
})
FocusTap(
offset = tapOffset,
onFocus = { onFocus { tapOffset = Offset.Zero } },
) { focusTapContent() }
if (isCameraIdle) {
latestBitmap?.let {
when (camSelector.selector.lensFacing) {
CameraXSelector.LENS_FACING_FRONT -> onSwipeToFront(it)
CameraXSelector.LENS_FACING_BACK -> onSwipeToBack(it)
else -> Unit
}
LaunchedEffect(latestBitmap) {
onPreviewStreamChanged()
if (latestBitmap != null) onZoomRatioChanged(cameraState.minZoom)
}
}
}
content()
}
| camerajetpackcompose/camposer/src/main/java/com/ujizin/camposer/CameraPreview.kt | 2846099883 |
package com.ujizin.camposer.state
import androidx.camera.core.ImageCapture
/**
* Camera Flash mode.
*
* @param mode internal flash mode from cameraX
* @see ImageCapture.FlashMode
* */
public enum class FlashMode(internal val mode: Int) {
On(ImageCapture.FLASH_MODE_ON),
Auto(ImageCapture.FLASH_MODE_AUTO),
Off(ImageCapture.FLASH_MODE_OFF);
/**
* Inverse flash mode. Works only with default Off & On flash modes.
* */
public val inverse: FlashMode
get() = when(this) {
On -> Off
else -> On
}
internal companion object {
internal fun find(mode: Int) = values().firstOrNull { it.mode == mode } ?: Off
}
}
| camerajetpackcompose/camposer/src/main/java/com/ujizin/camposer/state/FlashMode.kt | 1686691640 |
package com.ujizin.camposer.state
import androidx.camera.core.ImageAnalysis
import androidx.compose.runtime.Composable
import androidx.compose.runtime.MutableState
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.ui.platform.LocalContext
import com.ujizin.camposer.CameraPreview
/**
* Camera State from [CameraPreview] Composable.
* */
@Composable
public fun rememberCameraState(): CameraState {
val context = LocalContext.current
return remember { CameraState(context) }
}
/**
* Camera selector's State to [CameraPreview] Composable.
* */
@Composable
public fun rememberCamSelector(
selector: CamSelector = CamSelector.Back
): MutableState<CamSelector> = rememberSaveable(saver = CamSelector.Saver) {
mutableStateOf(selector)
}
/**
* Flash mode's State to [CameraPreview] Composable.
* */
@Composable
public fun CameraState.rememberFlashMode(
initialFlashMode: FlashMode = FlashMode.Off,
useSaver: Boolean = true
): MutableState<FlashMode> = rememberConditionalState(
initialValue = initialFlashMode,
defaultValue = FlashMode.Off,
useSaver = useSaver,
predicate = hasFlashUnit
)
/**
* Torch's State to [CameraPreview] Composable.
* */
@Composable
public fun CameraState.rememberTorch(
initialTorch: Boolean = false,
useSaver: Boolean = true
): MutableState<Boolean> = rememberConditionalState(
initialValue = initialTorch,
defaultValue = false,
useSaver = useSaver,
predicate = hasFlashUnit
)
/**
* Create instance remember of ImageAnalyzer.
*
* @see ImageAnalyzer
* */
@Composable
public fun CameraState.rememberImageAnalyzer(
imageAnalysisBackpressureStrategy: ImageAnalysisBackpressureStrategy = ImageAnalysisBackpressureStrategy.KeepOnlyLatest,
imageAnalysisTargetSize: ImageTargetSize? = ImageTargetSize(this.imageAnalysisTargetSize),
imageAnalysisImageQueueDepth: Int = this.imageAnalysisImageQueueDepth,
analyze: ImageAnalysis.Analyzer,
): ImageAnalyzer = remember(this) {
ImageAnalyzer(
this,
imageAnalysisBackpressureStrategy,
imageAnalysisTargetSize,
imageAnalysisImageQueueDepth,
analyze
)
}
| camerajetpackcompose/camposer/src/main/java/com/ujizin/camposer/state/CameraAsState.kt | 2484986731 |
package com.ujizin.camposer.state
import androidx.camera.view.PreviewView
/**
* Camera implementation mode.
*
* @param value internal implementation mode from cameraX
* @see PreviewView.ImplementationMode
* */
public enum class ImplementationMode(internal val value: PreviewView.ImplementationMode) {
Compatible(PreviewView.ImplementationMode.COMPATIBLE),
Performance(PreviewView.ImplementationMode.PERFORMANCE);
/**
* Inverse currently implementation mode.
* */
public val inverse: ImplementationMode
get() = when (this) {
Compatible -> Performance
else -> Compatible
}
} | camerajetpackcompose/camposer/src/main/java/com/ujizin/camposer/state/ImplementationMode.kt | 2991794372 |
package com.ujizin.camposer.state
import android.view.ScaleGestureDetector
internal class PinchToZoomGesture(
private val onZoomChanged: (Float) -> Unit
) : ScaleGestureDetector.SimpleOnScaleGestureListener() {
override fun onScale(detector: ScaleGestureDetector): Boolean {
onZoomChanged(detector.scaleFactor)
return true
}
} | camerajetpackcompose/camposer/src/main/java/com/ujizin/camposer/state/PinchToZoomGesture.kt | 1976809208 |
package com.ujizin.camposer.state
import androidx.camera.core.ImageAnalysis
import androidx.compose.runtime.Immutable
/**
* Intermediate Image analyzer from cameraX
*
* @param imageAnalysisBackpressureStrategy the backpressure strategy applied to the image producer
* @param imageAnalysisTargetSize the intended output size for ImageAnalysis
* @param imageAnalysisImageQueueDepth the image queue depth of ImageAnalysis.
* @param analyzer receive images and perform custom processing.
*
* @see rememberImageAnalyzer
* */
@Immutable
public class ImageAnalyzer(
private val cameraState: CameraState,
imageAnalysisBackpressureStrategy: ImageAnalysisBackpressureStrategy,
imageAnalysisTargetSize: ImageTargetSize?,
imageAnalysisImageQueueDepth: Int,
internal var analyzer: ImageAnalysis.Analyzer,
) {
init {
updateCameraState(
imageAnalysisBackpressureStrategy,
imageAnalysisTargetSize,
imageAnalysisImageQueueDepth
)
}
private fun updateCameraState(
imageAnalysisBackpressureStrategy: ImageAnalysisBackpressureStrategy,
imageAnalysisTargetSize: ImageTargetSize?,
imageAnalysisImageQueueDepth: Int,
) = with(cameraState) {
this.imageAnalysisBackpressureStrategy = imageAnalysisBackpressureStrategy.strategy
this.imageAnalysisTargetSize = imageAnalysisTargetSize?.toOutputSize()
this.imageAnalysisImageQueueDepth = imageAnalysisImageQueueDepth
}
/**
* Update actual image analysis instance.
* */
public fun update(
imageAnalysisBackpressureStrategy: ImageAnalysisBackpressureStrategy = ImageAnalysisBackpressureStrategy.find(
cameraState.imageAnalysisBackpressureStrategy
),
imageAnalysisTargetSize: ImageTargetSize? = ImageTargetSize(cameraState.imageAnalysisTargetSize),
imageAnalysisImageQueueDepth: Int = cameraState.imageAnalysisImageQueueDepth,
analyzer: ImageAnalysis.Analyzer = this.analyzer,
) {
updateCameraState(
imageAnalysisBackpressureStrategy,
imageAnalysisTargetSize,
imageAnalysisImageQueueDepth
)
this.analyzer = analyzer
}
}
| camerajetpackcompose/camposer/src/main/java/com/ujizin/camposer/state/ImageAnalyzer.kt | 132167482 |
package com.ujizin.camposer.state
import android.net.Uri
import androidx.compose.runtime.Immutable
/**
* Video Result of recording video.
*
* @see CameraState.startRecording
* @see CameraState.toggleRecording
* */
public sealed interface VideoCaptureResult {
@Immutable
public data class Success(val savedUri: Uri?) : VideoCaptureResult
@Immutable
public data class Error(
val videoCaptureError: Int,
val message: String,
val throwable: Throwable?
) : VideoCaptureResult
}
| camerajetpackcompose/camposer/src/main/java/com/ujizin/camposer/state/VideoCaptureResult.kt | 322891839 |
package com.ujizin.camposer.state
import androidx.camera.view.PreviewView.ScaleType as CameraScaleType
/**
* Camera scale type.
*
* @param type internal scale type from cameraX
* @see CameraScaleType
* */
public enum class ScaleType(public val type: CameraScaleType) {
FitStart(CameraScaleType.FIT_START),
FitCenter(CameraScaleType.FIT_CENTER),
FitEnd(CameraScaleType.FIT_END),
FillStart(CameraScaleType.FILL_START),
FillCenter(CameraScaleType.FILL_CENTER),
FillEnd(CameraScaleType.FILL_END),
}
| camerajetpackcompose/camposer/src/main/java/com/ujizin/camposer/state/ScaleType.kt | 3020976734 |
package com.ujizin.camposer.state
import android.annotation.SuppressLint
import androidx.camera.core.CameraSelector
import androidx.compose.runtime.MutableState
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.saveable.Saver
import androidx.compose.runtime.saveable.listSaver
/**
* Camera Selector.
*
* @param selector internal camera selector from CameraX
* @see CameraSelector
* */
public enum class CamSelector(
internal val selector: CameraSelector
) {
Front(CameraSelector.DEFAULT_FRONT_CAMERA),
Back(CameraSelector.DEFAULT_BACK_CAMERA);
/**
* Inverse camera selector. Works only with default Front & Back Selector.
* */
public val inverse: CamSelector
get() = when (this) {
Front -> Back
Back -> Front
}
internal companion object {
@SuppressLint("RestrictedApi")
internal val Saver: Saver<MutableState<CamSelector>, *> = listSaver(
save = { listOf(it.value.selector.lensFacing) },
restore = {
mutableStateOf(
when (it[0]) {
CameraSelector.LENS_FACING_FRONT -> Front
else -> Back
}
)
}
)
}
}
| camerajetpackcompose/camposer/src/main/java/com/ujizin/camposer/state/CamSelector.kt | 1503881536 |
package com.ujizin.camposer.state
import androidx.camera.core.ImageAnalysis
/**
* Image analysis backpressure strategy is used to camera operation mode.
*
* For more information, check it out [CameraX ImageAnalysis operating modes](https://developer.android.com/training/camerax/analyze#operating-modes)
* */
public enum class ImageAnalysisBackpressureStrategy(internal val strategy: Int) {
/**
* always caches the latest image, used for non-blocking operation.
* */
KeepOnlyLatest(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST),
/**
* add multiple images to the internal image queue and begin dropping frames only when the queue is full, used for blocking operation.
* */
BlockProducer(ImageAnalysis.STRATEGY_BLOCK_PRODUCER);
internal companion object {
internal fun find(strategy: Int) =
values().firstOrNull { it.strategy == strategy } ?: KeepOnlyLatest
}
} | camerajetpackcompose/camposer/src/main/java/com/ujizin/camposer/state/ImageAnalysisBackpressureStrategy.kt | 2942623967 |
package com.ujizin.camposer.state
import android.annotation.SuppressLint
import android.content.ContentResolver
import android.content.ContentValues
import android.content.Context
import android.hardware.camera2.CameraManager
import android.net.Uri
import android.os.Build
import android.provider.MediaStore
import android.util.Log
import androidx.annotation.ChecksSdkIntAtLeast
import androidx.annotation.OptIn
import androidx.annotation.RequiresApi
import androidx.annotation.VisibleForTesting
import androidx.camera.core.FocusMeteringAction
import androidx.camera.core.ImageAnalysis
import androidx.camera.core.ImageCapture
import androidx.camera.core.ImageCaptureException
import androidx.camera.core.MeteringPoint
import androidx.camera.core.TorchState
import androidx.camera.view.CameraController.IMAGE_ANALYSIS
import androidx.camera.view.CameraController.OutputSize
import androidx.camera.view.CameraController.OutputSize.UNASSIGNED_ASPECT_RATIO
import androidx.camera.view.LifecycleCameraController
import androidx.camera.view.video.ExperimentalVideo
import androidx.camera.view.video.OnVideoSavedCallback
import androidx.camera.view.video.OutputFileOptions
import androidx.camera.view.video.OutputFileResults
import androidx.compose.runtime.derivedStateOf
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import com.ujizin.camposer.extensions.compatMainExecutor
import com.ujizin.camposer.extensions.isImageAnalysisSupported
import java.io.File
import java.util.concurrent.Executor
/**
* A state object that can be hoisted to control camera, take picture or record video.
*
* To be created use [rememberCameraState].
* */
public class CameraState(context: Context) {
/**
* Main Executor to action as take picture or record.
* */
private val mainExecutor: Executor = context.compatMainExecutor
/**
* Content resolver to picture and video.
* */
private val contentResolver: ContentResolver = context.contentResolver
/**
* Check if focus metering is supported
* */
private val MeteringPoint.isFocusMeteringSupported: Boolean
get() = controller.cameraInfo?.isFocusMeteringSupported(
FocusMeteringAction.Builder(this).build()
) ?: false
/**
* Main controller from CameraX. useful in cases that haven't been release some feature yet.
* */
public val controller: LifecycleCameraController = LifecycleCameraController(context)
/**
* Get max zoom from camera.
* */
public var maxZoom: Float by mutableStateOf(
controller.zoomState.value?.maxZoomRatio ?: INITIAL_ZOOM_VALUE
)
internal set
/**
* Get min zoom from camera.
* */
public var minZoom: Float by mutableStateOf(
controller.zoomState.value?.minZoomRatio ?: INITIAL_ZOOM_VALUE
)
internal set
/**
* Get range compensation range from camera.
* */
private val exposureCompensationRange
get() = controller.cameraInfo?.exposureState?.exposureCompensationRange
/**
* Get min exposure from camera.
* */
public var minExposure: Int by mutableStateOf(
exposureCompensationRange?.lower ?: INITIAL_EXPOSURE_VALUE
)
internal set
/**
* Get max exposure from camera.
* */
public var maxExposure: Int by mutableStateOf(
exposureCompensationRange?.upper ?: INITIAL_EXPOSURE_VALUE
)
internal set
public val initialExposure: Int = INITIAL_EXPOSURE_VALUE
get() = controller.cameraInfo?.exposureState?.exposureCompensationIndex ?: field
/**
* Check if compensation exposure is supported.
* */
public val isExposureSupported: Boolean by derivedStateOf { maxExposure != INITIAL_EXPOSURE_VALUE }
/**
* Check if camera is streaming or not.
* */
public var isStreaming: Boolean by mutableStateOf(false)
internal set
/**
* Check if zoom is supported.
* */
public val isZoomSupported: Boolean by derivedStateOf { maxZoom != 1F }
/**
* Check if focus on tap supported
* */
public var isFocusOnTapSupported: Boolean by mutableStateOf(true)
/**
* Check if camera state is initialized or not.
* */
public var isInitialized: Boolean by mutableStateOf(false)
internal set
/**
* Verify if camera has flash or not.
* */
public var hasFlashUnit: Boolean by mutableStateOf(
controller.cameraInfo?.hasFlashUnit() ?: true
)
/**
* Capture mode to be added on camera.
* */
internal var captureMode: CaptureMode = CaptureMode.Image
set(value) {
if (field != value) {
field = value
updateUseCases()
}
}
/**
* Image capture mode to be added on camera.
* */
internal var imageCaptureMode: ImageCaptureMode = ImageCaptureMode.MinLatency
set(value) {
if (field != value) {
field = value
controller.imageCaptureMode = value.mode
}
}
/**
* Get scale type from the camera.
* */
internal var scaleType: ScaleType = ScaleType.FillCenter
/**
* Get implementation mode from the camera.
* */
internal var implementationMode: ImplementationMode = ImplementationMode.Performance
/**
* Camera mode, it can be front or back.
* @see CamSelector
* */
internal var camSelector: CamSelector = CamSelector.Back
set(value) {
when {
value == field -> Unit
!isRecording && hasCamera(value) -> {
if (controller.cameraSelector != value.selector) {
controller.cameraSelector = value.selector
field = value
resetCamera()
}
}
isRecording -> Log.e(TAG, "Device is recording, switch camera is unavailable")
else -> Log.e(TAG, "Device does not have ${value.selector} camera")
}
}
/**
* Set image capture target size on camera
* */
internal var imageCaptureTargetSize: ImageTargetSize?
get() = controller.imageCaptureTargetSize.toImageTargetSize()
set(value) {
if (value != imageCaptureTargetSize) {
controller.imageCaptureTargetSize = value?.toOutputSize()
}
}
/**
* Get Image Analyzer from camera.
* */
internal var imageAnalyzer: ImageAnalysis.Analyzer? = null
set(value) {
field = value
with(controller) {
clearImageAnalysisAnalyzer()
setImageAnalysisAnalyzer(mainExecutor, value ?: return)
}
}
private val cameraManager = context.getSystemService(Context.CAMERA_SERVICE) as? CameraManager
/**
* Check if image analysis is supported by camera hardware level.
* */
public var isImageAnalysisSupported: Boolean by mutableStateOf(isImageAnalysisSupported(camSelector))
private set
/**
* CameraX's use cases captures.
* */
private val captureUseCases: MutableSet<Int> = mutableSetOf<Int>().apply {
if (isImageAnalysisSupported) add(IMAGE_ANALYSIS)
}
/**
* Enable/Disable Image analysis from the camera.
* */
internal var isImageAnalysisEnabled: Boolean = isImageAnalysisSupported
set(value) {
if (!isImageAnalysisSupported) {
Log.e(TAG, "Image analysis is not supported")
return
}
if (value != field) {
if (value) captureUseCases += IMAGE_ANALYSIS else captureUseCases -= IMAGE_ANALYSIS
updateUseCases()
field = value
}
}
private fun updateUseCases() {
try {
controller.setEnabledUseCases(captureUseCases.sumOr(captureMode.value))
} catch (exception: IllegalStateException) {
Log.e(TAG, "Use case Image Analysis not supported")
controller.setEnabledUseCases(captureMode.value)
}
}
/**
* Image analysis backpressure strategy, use [rememberImageAnalyzer] to set value.
* */
internal var imageAnalysisBackpressureStrategy: Int
get() = controller.imageAnalysisBackpressureStrategy
set(value) {
if (imageAnalysisBackpressureStrategy != value) {
controller.imageAnalysisBackpressureStrategy = value
}
}
/**
* Image analysis target size, use [rememberImageAnalyzer] to set value.
* @see rememberImageAnalyzer
* */
internal var imageAnalysisTargetSize: OutputSize?
get() = controller.imageAnalysisTargetSize
set(value) {
if (imageAnalysisTargetSize != value) {
controller.imageAnalysisTargetSize = value
}
}
/**
* Image analysis image queue depth, use [rememberImageAnalyzer] to set value.
* @see rememberImageAnalyzer
* */
internal var imageAnalysisImageQueueDepth: Int
get() = controller.imageAnalysisImageQueueDepth
set(value) {
if (imageAnalysisImageQueueDepth != value) {
controller.imageAnalysisImageQueueDepth = value
}
}
/**
* Get if focus on tap is enabled from cameraX.
* */
internal var isFocusOnTapEnabled: Boolean
get() = controller.isTapToFocusEnabled
set(value) {
controller.isTapToFocusEnabled = value
}
/**
* Flash Mode from the camera.
* @see FlashMode
* */
internal var flashMode: FlashMode
get() = FlashMode.find(controller.imageCaptureFlashMode)
set(value) {
if (hasFlashUnit && flashMode != value) {
controller.imageCaptureFlashMode = value.mode
}
}
/**
* Enabled/Disable torch from camera.
* */
internal var enableTorch: Boolean
get() = controller.torchState.value == TorchState.ON
set(value) {
if (enableTorch != value) {
controller.enableTorch(hasFlashUnit && value)
}
}
/**
* Return if video is supported.
* */
@ChecksSdkIntAtLeast(Build.VERSION_CODES.M)
public var isVideoSupported: Boolean = Build.VERSION.SDK_INT >= Build.VERSION_CODES.M
/**
* Return true if it's recording.
* */
@ExperimentalVideo
public var isRecording: Boolean by mutableStateOf(controller.isRecording)
private set
init {
controller.initializationFuture.addListener({
resetCamera()
isInitialized = true
}, mainExecutor)
}
private fun startExposure() {
minExposure = exposureCompensationRange?.lower ?: INITIAL_EXPOSURE_VALUE
maxExposure = exposureCompensationRange?.upper ?: INITIAL_EXPOSURE_VALUE
}
/**
* Take a picture with the camera.
*
* @param saveCollection Uri collection where the photo will be saved.
* @param contentValues Content values of the photo.
* @param onResult Callback called when [ImageCaptureResult] is ready
* */
public fun takePicture(
contentValues: ContentValues,
saveCollection: Uri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
onResult: (ImageCaptureResult) -> Unit,
) {
takePicture(
outputFileOptions = ImageCapture.OutputFileOptions.Builder(
contentResolver, saveCollection, contentValues
).build(), onResult = onResult
)
}
/**
* Take a picture with the camera.
* @param file file where the photo will be saved
* @param onResult Callback called when [ImageCaptureResult] is ready
* */
public fun takePicture(
file: File, onResult: (ImageCaptureResult) -> Unit
) {
takePicture(ImageCapture.OutputFileOptions.Builder(file).build(), onResult)
}
/**
* Take a picture with the camera.
*
* @param outputFileOptions Output file options of the photo.
* @param onResult Callback called when [ImageCaptureResult] is ready
* */
public fun takePicture(
outputFileOptions: ImageCapture.OutputFileOptions,
onResult: (ImageCaptureResult) -> Unit,
) {
try {
controller.takePicture(outputFileOptions,
mainExecutor,
object : ImageCapture.OnImageSavedCallback {
override fun onImageSaved(outputFileResults: ImageCapture.OutputFileResults) {
onResult(ImageCaptureResult.Success(outputFileResults.savedUri))
}
override fun onError(exception: ImageCaptureException) {
onResult(ImageCaptureResult.Error(exception))
}
})
} catch (exception: Exception) {
onResult(ImageCaptureResult.Error(exception))
}
}
/**
* Set zoom ratio to camera.
* @param zoomRatio zoomRatio to be added
* */
private fun setZoomRatio(zoomRatio: Float) {
controller.setZoomRatio(zoomRatio.coerceIn(minZoom, maxZoom))
}
private fun setExposureCompensation(exposureCompensation: Int) {
controller.cameraControl?.setExposureCompensationIndex(exposureCompensation)
}
/**
* Start recording camera.
*
* @param file file where the video will be saved
* @param onResult Callback called when [VideoCaptureResult] is ready
* */
@OptIn(markerClass = [ExperimentalVideo::class])
@RequiresApi(Build.VERSION_CODES.M)
public fun startRecording(file: File, onResult: (VideoCaptureResult) -> Unit) {
startRecording(OutputFileOptions.builder(file).build(), onResult)
}
/**
* Start recording camera.
*
* @param saveCollection Uri collection where the video will be saved.
* @param contentValues Content values of the video.
* @param onResult Callback called when [VideoCaptureResult] is ready
* */
@OptIn(markerClass = [ExperimentalVideo::class])
@RequiresApi(Build.VERSION_CODES.M)
public fun startRecording(
saveCollection: Uri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI,
contentValues: ContentValues,
onResult: (VideoCaptureResult) -> Unit,
) {
startRecording(
OutputFileOptions.builder(contentResolver, saveCollection, contentValues).build(),
onResult
)
}
/**
* Start recording camera.
*
* @param outputFileOptions Output file options of the video.
* @param onResult Callback called when [VideoCaptureResult] is ready
* */
@ExperimentalVideo
@RequiresApi(Build.VERSION_CODES.M)
public fun startRecording(
outputFileOptions: OutputFileOptions,
onResult: (VideoCaptureResult) -> Unit,
) {
try {
isRecording = true
controller.startRecording(outputFileOptions,
mainExecutor,
object : OnVideoSavedCallback {
override fun onVideoSaved(outputFileResults: OutputFileResults) {
isRecording = false
onResult(VideoCaptureResult.Success(outputFileResults.savedUri))
}
override fun onError(
videoCaptureError: Int, message: String, cause: Throwable?
) {
isRecording = false
onResult(VideoCaptureResult.Error(videoCaptureError, message, cause))
}
})
} catch (exception: Exception) {
isRecording = false
onResult(
VideoCaptureResult.Error(
OnVideoSavedCallback.ERROR_UNKNOWN, if (!controller.isVideoCaptureEnabled) {
"Video capture is not enabled, please set captureMode as CaptureMode.Video"
} else "${exception.message}", exception
)
)
}
}
/**
* Stop recording camera.
* */
@OptIn(markerClass = [ExperimentalVideo::class])
@RequiresApi(Build.VERSION_CODES.M)
public fun stopRecording() {
controller.stopRecording()
}
/**
* Toggle recording camera.
* */
@RequiresApi(Build.VERSION_CODES.M)
public fun toggleRecording(
file: File,
onResult: (VideoCaptureResult) -> Unit
) {
when (isRecording) {
true -> stopRecording()
false -> startRecording(file, onResult)
}
}
/**
* Toggle recording camera.
* */
@RequiresApi(Build.VERSION_CODES.M)
public fun toggleRecording(
contentValues: ContentValues,
saveCollection: Uri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI,
onResult: (VideoCaptureResult) -> Unit
) {
when (isRecording) {
true -> stopRecording()
false -> startRecording(saveCollection, contentValues, onResult)
}
}
/**
* Toggle recording camera.
* */
@RequiresApi(Build.VERSION_CODES.M)
@OptIn(markerClass = [ExperimentalVideo::class])
public fun toggleRecording(
outputFileOptions: OutputFileOptions,
onResult: (VideoCaptureResult) -> Unit
) {
when (isRecording) {
true -> stopRecording()
false -> startRecording(outputFileOptions, onResult)
}
}
/**
* Return if has camera selector or not, camera must be initialized, otherwise result is false.
* */
public fun hasCamera(cameraSelector: CamSelector): Boolean =
isInitialized && controller.hasCamera(cameraSelector.selector)
private fun startZoom() {
// Turn off is pinch to zoom and use manually
controller.isPinchToZoomEnabled = false
val zoom = controller.zoomState.value
minZoom = zoom?.minZoomRatio ?: INITIAL_ZOOM_VALUE
maxZoom = zoom?.maxZoomRatio ?: INITIAL_ZOOM_VALUE
}
private fun resetCamera() {
hasFlashUnit = controller.cameraInfo?.hasFlashUnit() ?: false
isImageAnalysisSupported = isImageAnalysisSupported(camSelector)
startZoom()
startExposure()
}
private fun Set<Int>.sumOr(initial: Int = 0): Int = fold(initial) { acc, current ->
acc or current
}
@SuppressLint("RestrictedApi")
@VisibleForTesting
internal fun isImageAnalysisSupported(
cameraSelector: CamSelector = camSelector
): Boolean = cameraManager?.isImageAnalysisSupported(cameraSelector.selector.lensFacing) ?: false
/**
* Update all values from camera state.
* */
internal fun update(
camSelector: CamSelector,
captureMode: CaptureMode,
scaleType: ScaleType,
imageCaptureTargetSize: ImageTargetSize?,
isImageAnalysisEnabled: Boolean,
imageAnalyzer: ImageAnalyzer?,
implementationMode: ImplementationMode,
isFocusOnTapEnabled: Boolean,
flashMode: FlashMode,
zoomRatio: Float,
imageCaptureMode: ImageCaptureMode,
enableTorch: Boolean,
meteringPoint: MeteringPoint,
exposureCompensation: Int
) {
this.camSelector = camSelector
this.captureMode = captureMode
this.scaleType = scaleType
this.imageCaptureTargetSize = imageCaptureTargetSize
this.isImageAnalysisEnabled = isImageAnalysisEnabled
this.imageAnalyzer = imageAnalyzer?.analyzer
this.implementationMode = implementationMode
this.isFocusOnTapEnabled = isFocusOnTapEnabled
this.flashMode = flashMode
this.enableTorch = enableTorch
this.isFocusOnTapSupported = meteringPoint.isFocusMeteringSupported
this.imageCaptureMode = imageCaptureMode
setExposureCompensation(exposureCompensation)
setZoomRatio(zoomRatio)
}
private companion object {
private val TAG = this::class.java.name
private const val INITIAL_ZOOM_VALUE = 1F
private const val INITIAL_EXPOSURE_VALUE = 0
}
}
private fun OutputSize?.toImageTargetSize(): ImageTargetSize? {
return this?.let {
if (it.aspectRatio != UNASSIGNED_ASPECT_RATIO) {
ImageTargetSize(aspectRatio = it.aspectRatio)
} else {
ImageTargetSize(size = it.resolution)
}
}
}
| camerajetpackcompose/camposer/src/main/java/com/ujizin/camposer/state/CameraState.kt | 3532671304 |
package com.ujizin.camposer.state
import androidx.camera.core.ExperimentalZeroShutterLag
import androidx.camera.core.ImageCapture
/**
* Camera Image Capture mode.
*
* @param mode internal camera image capture mode from CameraX
* @see ImageCapture.CAPTURE_MODE_ZERO_SHUTTER_LAG
* @see ImageCapture.CAPTURE_MODE_MAXIMIZE_QUALITY
* @see ImageCapture.CAPTURE_MODE_MINIMIZE_LATENCY
* */
public enum class ImageCaptureMode(@ImageCapture.CaptureMode internal val mode: Int) {
@ExperimentalZeroShutterLag
ZeroShutterLag(ImageCapture.CAPTURE_MODE_ZERO_SHUTTER_LAG),
MaxQuality(ImageCapture.CAPTURE_MODE_MAXIMIZE_QUALITY),
MinLatency(ImageCapture.CAPTURE_MODE_MINIMIZE_LATENCY);
}
| camerajetpackcompose/camposer/src/main/java/com/ujizin/camposer/state/ImageCaptureMode.kt | 465417566 |
package com.ujizin.camposer.state
import androidx.compose.runtime.Composable
import androidx.compose.runtime.MutableState
import androidx.compose.runtime.Stable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.saveable.Saver
import androidx.compose.runtime.saveable.listSaver
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
@Stable
internal class ConditionalState<T : Any>(
startValue: T,
private val defaultValue: T,
) : MutableState<T> {
internal var predicate: Boolean = true
private fun getMode(value: T): T = when {
predicate -> value
else -> defaultValue
}
private var _value by mutableStateOf(getMode(startValue))
override var value: T
get() = getMode(_value)
set(value) {
_value = getMode(value)
}
override fun component1(): T = _value
override fun component2(): (T) -> Unit = { _value = it }
companion object {
internal fun <T : Any> getNoSaver(
startValue: T,
defaultValue: T
): Saver<ConditionalState<T>, *> = listSaver(
save = { listOf(startValue, defaultValue) },
restore = { ConditionalState(it[0], it[1]) }
)
internal fun <T : Any> getSaver(): Saver<ConditionalState<T>, *> = listSaver(
save = { listOf(it._value, it.defaultValue) },
restore = { ConditionalState(it[0], it[1]) }
)
}
}
/**
* Remember with [ConditionalState].
*
* @param initialValue The initial value of state.
* @param defaultValue The Default value of state, if predicate is false then it's applied it.
* @param useSaver if true saves the latest value on state.
* @param predicate conditional to get actual value or default value.
* */
@Composable
internal fun <T : Any> rememberConditionalState(
initialValue: T,
defaultValue: T,
useSaver: Boolean,
predicate: Boolean
): MutableState<T> {
var current by remember { mutableStateOf(initialValue) }
return rememberSaveable(
predicate, saver = when (useSaver) {
true -> ConditionalState.getSaver()
else -> ConditionalState.getNoSaver(current, defaultValue)
}
) {
ConditionalState(current, defaultValue).apply {
this.predicate = predicate
current = value
}
}
}
| camerajetpackcompose/camposer/src/main/java/com/ujizin/camposer/state/ConditionalState.kt | 836121268 |
package com.ujizin.camposer.state
import android.util.Size
import androidx.camera.core.AspectRatio
import androidx.camera.view.CameraController.OutputSize
/**
* Image Analysis target size is used to target the size of image analysis, accepting [AspectRatio]
* or [Size].
* */
public data class ImageTargetSize(
private var aspectRatio: Int? = null,
private var size: Size? = null,
private var outputSize: OutputSize? = null
) {
/**
* Image analysis target size using [AspectRatio].
* */
public constructor(@AspectRatio.Ratio aspectRatio: Int?) : this(
aspectRatio = aspectRatio,
size = null,
outputSize = null
)
/**
* Image analysis target size using [Size].
* */
public constructor(size: Size?) : this(
aspectRatio = null,
size = size,
outputSize = null
)
/**
* Internal constructor to use default [OutputSize] from cameraX.
* */
internal constructor(outputSize: OutputSize?) : this(
aspectRatio = null,
size = null,
outputSize = outputSize
)
internal fun toOutputSize(): OutputSize? {
return outputSize ?: aspectRatio?.let { OutputSize(it) } ?: size?.let { OutputSize(it) }
}
}
| camerajetpackcompose/camposer/src/main/java/com/ujizin/camposer/state/ImageTargetSize.kt | 2755879240 |
package com.ujizin.camposer.state
import android.net.Uri
import androidx.compose.runtime.Immutable
/**
* Photo Result of taking picture.
*
* @see CameraState.takePicture
* */
public sealed interface ImageCaptureResult {
@Immutable
public data class Success(val savedUri: Uri?) : ImageCaptureResult
@Immutable
public data class Error(val throwable: Throwable) : ImageCaptureResult
}
| camerajetpackcompose/camposer/src/main/java/com/ujizin/camposer/state/ImageCaptureResult.kt | 2284911006 |
package com.ujizin.camposer.state
import android.os.Build
import androidx.annotation.OptIn
import androidx.annotation.RequiresApi
import androidx.camera.view.CameraController.IMAGE_CAPTURE
import androidx.camera.view.CameraController.VIDEO_CAPTURE
import androidx.camera.view.video.ExperimentalVideo
/**
* Camera Capture mode.
*
* @param value internal camera capture from CameraX
* @see IMAGE_CAPTURE
* @see VIDEO_CAPTURE
* */
@OptIn(markerClass = [ExperimentalVideo::class])
public enum class CaptureMode(internal val value: Int) {
Image(IMAGE_CAPTURE),
@RequiresApi(Build.VERSION_CODES.M)
Video(VIDEO_CAPTURE),
}
| camerajetpackcompose/camposer/src/main/java/com/ujizin/camposer/state/CaptureMode.kt | 3735148270 |
package com.ujizin.camposer.focus
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.graphics.Brush
import androidx.compose.ui.graphics.drawscope.DrawScope
import androidx.compose.ui.unit.Dp
private class CornerBorder(
drawScope: DrawScope,
val x: Float,
val y: Float,
val thicknessDp: Dp,
val brush: Brush,
val borderSize: Dp
) {
val thickness: Float
val borderAdjust: Float
val cornerSize: Float
val cornerStartX: Float
val cornerEndX: Float
val cornerStartY: Float
val cornerEndY: Float
init {
with(drawScope) {
thickness = thicknessDp.value * density
borderAdjust = thickness / ADJUST_THICKNESS_HALF_SIZE
cornerSize = when {
borderSize != Dp.Unspecified -> borderSize.value * density
else -> x / DEFAULT_SIZE
}
cornerStartX = x - cornerSize
cornerStartY = y - cornerSize
cornerEndX = x - borderAdjust
cornerEndY = y - borderAdjust
drawBottomStartCornerLine()
drawBottomEndCornerLine()
drawTopStartCornerLine()
drawTopEndCornerLine()
}
}
private fun DrawScope.drawTopEndCornerLine() {
drawLine(brush, Offset(cornerStartX, 0f), Offset(x, 0f), thickness)
drawLine(brush, Offset(cornerEndX, 0f), Offset(cornerEndX, cornerSize), thickness)
}
private fun DrawScope.drawTopStartCornerLine() {
drawLine(brush, Offset(0f, 0f), Offset(cornerSize, 0f), thickness)
drawLine(brush, Offset(borderAdjust, 0f), Offset(borderAdjust, cornerSize), thickness)
}
private fun DrawScope.drawBottomEndCornerLine() {
drawLine(brush, Offset(cornerStartX, y), Offset(x, y), thickness)
drawLine(brush, Offset(cornerEndX, y), Offset(cornerEndX, cornerStartY), thickness)
}
private fun DrawScope.drawBottomStartCornerLine() {
drawLine(brush, Offset(0f, y), Offset(cornerSize, y), thickness)
drawLine(brush, Offset(borderAdjust, y), Offset(borderAdjust, cornerStartY), thickness)
}
companion object {
private const val DEFAULT_SIZE = 4
private const val ADJUST_THICKNESS_HALF_SIZE = 2
}
}
internal fun DrawScope.drawCornerBorder(brush: Brush, x: Float, y: Float, thickness: Dp, borderSize: Dp) {
CornerBorder(this, x, y, thickness, brush, borderSize)
} | camerajetpackcompose/camposer/src/main/java/com/ujizin/camposer/focus/CornerBorder.kt | 1062287678 |
package com.ujizin.camposer.focus
import androidx.compose.animation.core.AnimationSpec
import androidx.compose.animation.core.LinearOutSlowInEasing
import androidx.compose.animation.core.animateFloatAsState
import androidx.compose.animation.core.tween
import androidx.compose.foundation.BorderStroke
import androidx.compose.foundation.border
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.State
import androidx.compose.runtime.derivedStateOf
import androidx.compose.runtime.getValue
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.drawBehind
import androidx.compose.ui.draw.scale
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.layout.layout
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import kotlin.math.roundToInt
@Composable
internal fun FocusTap(
modifier: Modifier = Modifier,
offset: Offset,
onFocus: suspend () -> Unit = {},
focusContent: @Composable () -> Unit = {}
) {
val isFocused by remember(offset) { derivedStateOf { offset != Offset.Zero } }
if (isFocused) {
val focusMovable = remember(offset) {
movableContentOf {
Box(
Modifier
.then(modifier)
.layout { measurable, constraints ->
val placeable = measurable.measure(constraints)
layout(placeable.width, placeable.height) {
val relativeX = offset.x.roundToInt() - placeable.width / 2
val relativeY = offset.y.roundToInt() - placeable.height / 2
placeable.placeRelative(relativeX, relativeY)
}
}
) {
focusContent()
}
}
}
focusMovable()
LaunchedEffect(offset) { onFocus() }
}
}
/**
* Square corner shape composable, it only has shapes on corner border.
* */
@Composable
public fun SquareCornerFocus(
modifier: Modifier = Modifier,
tapSize: Dp = DefaultFocusSize,
borderSize: Dp = Dp.Unspecified,
borderStroke: BorderStroke = DefaultBorderStroke,
) {
val scaleAnim by scaleAsState()
Box(
Modifier
.size(tapSize)
.scale(scaleAnim)
.drawBehind {
drawCornerBorder(
brush = borderStroke.brush,
x = size.width,
y = size.height,
thickness = borderStroke.width,
borderSize = borderSize
)
}
.then(modifier),
)
}
/**
* Square focus shape composable.
* */
@Composable
public fun SquareFocus(
modifier: Modifier = Modifier,
tapSize: Dp = DefaultFocusSize,
borderStroke: BorderStroke = DefaultBorderStroke,
) {
val scaleAnim by scaleAsState()
Box(
Modifier
.size(tapSize)
.scale(scaleAnim)
.border(borderStroke)
.then(modifier),
)
}
/**
* Circle focus shape composable.
* */
@Composable
public fun CircleFocus(
modifier: Modifier = Modifier,
tapSize: Dp = DefaultFocusSize,
borderStroke: BorderStroke = DefaultBorderStroke,
) {
val scaleAnim by scaleAsState()
Box(
Modifier
.size(tapSize)
.scale(scaleAnim)
.border(borderStroke, CircleShape)
.then(modifier),
)
}
@Composable
internal fun scaleAsState(
initialValue: Float = 1.5F,
targetValue: Float = 1F,
animationSpec: AnimationSpec<Float>? = null,
): State<Float> {
var scale by remember { mutableStateOf(initialValue) }
LaunchedEffect(scale) { scale = targetValue }
return animateFloatAsState(
targetValue = scale,
animationSpec = animationSpec ?: tween(easing = LinearOutSlowInEasing)
)
}
private val DefaultFocusSize = 64.dp
private val DefaultBorderStroke = BorderStroke(2.dp, Color.White) | camerajetpackcompose/camposer/src/main/java/com/ujizin/camposer/focus/FocusTap.kt | 4168659313 |
package com.ujizin.camposer.extensions
internal fun Float.clamped(scaleFactor: Float) = this * if (scaleFactor > 1f) {
1.0f + (scaleFactor - 1.0f) * 2
} else {
1.0f - (1.0f - scaleFactor) * 2
} | camerajetpackcompose/camposer/src/main/java/com/ujizin/camposer/extensions/FloatExtensions.kt | 3379058394 |
package com.ujizin.camposer.extensions
import android.hardware.camera2.CameraCharacteristics
import android.hardware.camera2.CameraManager
import com.ujizin.camposer.helper.CameraHelper
internal fun CameraManager.isImageAnalysisSupported(lensFacing: Int?): Boolean {
val cameraId = cameraIdList.firstOrNull {
getCameraCharacteristics(it).get(CameraCharacteristics.LENS_FACING) == lensFacing
} ?: return false
val level = getCameraCharacteristics(cameraId)
.get(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL) ?: 0
return level >= CameraHelper.compatHardwareLevel3
}
| camerajetpackcompose/camposer/src/main/java/com/ujizin/camposer/extensions/CameraManagerExtensions.kt | 1144524020 |
package com.ujizin.camposer.extensions
import android.content.Context
import android.os.Build
import android.os.Handler
import java.util.concurrent.Executor
private class MainThreadExecutor(context: Context) : Executor {
private val handler: Handler = Handler(context.mainLooper)
override fun execute(r: Runnable) {
handler.post(r)
}
}
internal val Context.compatMainExecutor: Executor
get() = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
mainExecutor
} else {
MainThreadExecutor(this)
}
| camerajetpackcompose/camposer/src/main/java/com/ujizin/camposer/extensions/ContextExtensions.kt | 3384972410 |
package com.ujizin.camposer.extensions
import android.annotation.SuppressLint
import android.view.MotionEvent
import android.view.ScaleGestureDetector
import android.view.ViewConfiguration.getLongPressTimeout
import androidx.camera.view.PreviewView
import androidx.compose.ui.geometry.Offset
import com.ujizin.camposer.state.PinchToZoomGesture
@SuppressLint("ClickableViewAccessibility")
internal fun PreviewView.onCameraTouchEvent(
onTap: (Offset) -> Unit,
onScaleChanged: (Float) -> Unit,
) {
val scaleGesture = ScaleGestureDetector(context, PinchToZoomGesture(onScaleChanged))
setOnTouchListener { _, event ->
val isSingleTouch = event.pointerCount == 1
val isUpEvent = event.action == MotionEvent.ACTION_UP
val notALongPress = (event.eventTime - event.downTime) < getLongPressTimeout()
if (isSingleTouch && isUpEvent && notALongPress) {
onTap(Offset(event.x, event.y))
}
scaleGesture.onTouchEvent(event) && onTouchEvent(event)
}
} | camerajetpackcompose/camposer/src/main/java/com/ujizin/camposer/extensions/PreviewViewExtensions.kt | 3053653085 |
package com.ujizin.camposer.extensions
import android.content.ContentValues
import android.net.Uri
import android.os.Build
import android.provider.MediaStore
import androidx.annotation.RequiresApi
import androidx.camera.core.ImageCapture
import androidx.camera.view.video.OutputFileOptions
import com.ujizin.camposer.state.CameraState
import com.ujizin.camposer.state.ImageCaptureResult
import com.ujizin.camposer.state.VideoCaptureResult
import kotlinx.coroutines.suspendCancellableCoroutine
import java.io.File
import kotlin.coroutines.Continuation
import kotlin.coroutines.resume
import kotlin.coroutines.resumeWithException
/**
* Transform takePicture file to suspend function
* */
public suspend fun CameraState.takePicture(file: File): Uri? = suspendCancellableCoroutine { cont ->
with(cont) { takePicture(file, ::takePictureContinuation) }
}
/**
* Transform takePicture content values to suspend function
* */
public suspend fun CameraState.takePicture(
contentValues: ContentValues,
saveCollection: Uri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
): Uri? = suspendCancellableCoroutine { cont ->
with(cont) { takePicture(contentValues, saveCollection, ::takePictureContinuation) }
}
/**
* Transform takePicture output files options to suspend function
* */
public suspend fun CameraState.takePicture(
outputFileOptions: ImageCapture.OutputFileOptions,
): Uri? = suspendCancellableCoroutine { cont ->
with(cont) { takePicture(outputFileOptions, ::takePictureContinuation) }
}
/**
* Transform toggle recording file to suspend function
* */
@RequiresApi(Build.VERSION_CODES.M)
public suspend fun CameraState.toggleRecording(file: File): Uri? = suspendCancellableCoroutine { cont ->
with(cont) { toggleRecording(file, ::toggleRecordContinuation) }
}
/**
* Transform toggle recording content values options to suspend function
* */
@RequiresApi(Build.VERSION_CODES.M)
public suspend fun CameraState.toggleRecording(
contentValues: ContentValues,
saveCollection: Uri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI
): Uri? = suspendCancellableCoroutine { cont ->
with(cont) { toggleRecording(contentValues, saveCollection, ::toggleRecordContinuation) }
}
/**
* Transform toggle recording output files options to suspend function
* */
@RequiresApi(Build.VERSION_CODES.M)
public suspend fun CameraState.toggleRecording(
outputFileOptions: OutputFileOptions
): Uri? = suspendCancellableCoroutine { cont ->
with(cont) { toggleRecording(outputFileOptions, ::toggleRecordContinuation) }
}
private fun Continuation<Uri?>.takePictureContinuation(result: ImageCaptureResult) {
when (val res: ImageCaptureResult = result) {
is ImageCaptureResult.Error -> resumeWithException(res.throwable)
is ImageCaptureResult.Success -> resume(res.savedUri)
}
}
private fun Continuation<Uri?>.toggleRecordContinuation(result: VideoCaptureResult) {
when (val res: VideoCaptureResult = result) {
is VideoCaptureResult.Error -> resumeWithException(res.throwable ?: Exception(res.message))
is VideoCaptureResult.Success -> resume(res.savedUri)
}
}
| camerajetpackcompose/camposer/src/main/java/com/ujizin/camposer/extensions/CameraStateExtensions.kt | 2586674574 |
package com.ujizin.camposer.helper
import android.hardware.camera2.CameraCharacteristics
import android.os.Build
internal object CameraHelper {
private const val COMPAT_HARDWARE_LEVEL_3 = 3
internal val compatHardwareLevel3: Int = when {
Build.VERSION.SDK_INT >= Build.VERSION_CODES.N -> CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_3
else -> COMPAT_HARDWARE_LEVEL_3
}
}
| camerajetpackcompose/camposer/src/main/java/com/ujizin/camposer/helper/CameraHelper.kt | 903732241 |
import java.util.Scanner
fun main() {
// Task 1
val scanner = Scanner(System.`in`)
print("Enter name: ")
val name = scanner.next()
print("Enter surname: ")
val surname = scanner.next()
print("Enter age: ")
var age: Int? = null
while (age == null || age <= 0) {
if (scanner.hasNextInt()) {
age = scanner.nextInt()
if (age <= 0) {
println("\nPlease enter a valid age (positive integer).")
print("Enter age: ")
}
} else {
println("Please enter a valid age (positive integer).")
print("Enter age: ")
scanner.next()
}
}
print("Enter height: ")
var height: Double? = null
while (height == null || height <= 0) {
if (scanner.hasNextDouble()) {
height = scanner.nextDouble()
if (height <= 0) {
println("\nPlease enter a valid height (positive number).")
print("Enter height: ")
}
} else {
println("Please enter a valid height (positive number).")
print("Enter height: ")
scanner.next()
}
}
if (age is Int && height is Double) {
println("$name $surname $age $height")
}
println("\n");
// Task 2
print("Calculate cycle (1 -> the area of the circle; 2 -> the length of the circumference):")
val choose = scanner.nextInt()
print("Enter radius:")
val radius = scanner.nextDouble()
when (choose) {
1 -> {
val area = 3.14 * (radius * radius)
println(area)
}
2 -> {
val length = 2 * 3.14 * radius
println(length)
}
else -> {
print("The fallacy of choice")
}
}
println("\n");
// Task 3
while (true) {
print("Calculate cycle (1 -> the area of the circle; 2 -> the length of the circumference):")
val choose2 = scanner.nextInt()
if (choose2 == 0) {
break;
} else {
print("Enter radius:")
val radius2 = scanner.nextDouble()
when (choose2) {
1 -> {
val area = 3.14 * (radius2 * radius2)
println(area)
}
2 -> {
val length = 2 * 3.14 * radius2
println(length)
}
else -> {
print("The fallacy of choice")
}
}
}
}
println("\n");
// Task 4
while (true) {
print("\nEnter number1: ")
var number1: Double? = null
while (number1 == null || number1 <= 0) {
if (scanner.hasNextDouble()) {
number1 = scanner.nextDouble()
} else {
println("\nPlease enter a valid number1")
print("Enter number1: ")
scanner.next()
}
}
print("Enter number2: ")
var number2: Double? = null
while (number2 == null || number2 <= 0) {
if (scanner.hasNextDouble()) {
number2 = scanner.nextDouble()
} else {
println("\nPlease enter a valid number2")
print("Enter number2: ")
scanner.next()
}
}
print("\n1 <- + \n2 <- - \n3 <- * \n4 <- / \n\nCalculate operation : ")
var choose4: Int? = null
while (choose4 == null || choose4 <= 0) {
if (scanner.hasNextInt()) {
choose4 = scanner.nextInt()
} else {
println("\n" + "\n" + "Please enter a only integer")
print("Calculate operation : ")
scanner.next()
}
}
when (choose4) {
1 -> {
println(number1 + number2)
}
2 -> {
println(number1 - number2)
}
3 -> {
println(number1 * number2)
}
4 -> {
println(number1 / number2)
}
else -> {
print("\nThe fallacy of choice")
break;
}
}
}
}
| KotlinLesson2/src/main/kotlin/Main.kt | 1754374258 |
package com.hfad.myconstraintlayout
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("com.hfad.myconstraintlayout", appContext.packageName)
}
} | headfirst-ch5-krmacdonald/app/src/androidTest/java/com/hfad/myconstraintlayout/ExampleInstrumentedTest.kt | 334748180 |
package com.hfad.myconstraintlayout
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)
}
} | headfirst-ch5-krmacdonald/app/src/test/java/com/hfad/myconstraintlayout/ExampleUnitTest.kt | 397471134 |
package com.hfad.myconstraintlayout
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
}
} | headfirst-ch5-krmacdonald/app/src/main/java/com/hfad/myconstraintlayout/MainActivity.kt | 1263997265 |
package fr.imacaron.presentationtest.unit
import fr.imacaron.presentationtest.core.port.UserRepository
import fr.imacaron.presentationtest.core.service.UserService
import fr.imacaron.presentationtest.core.type.User
import fr.imacaron.presentationtest.core.type.UserCreation
import fr.imacaron.presentationtest.core.type.UserUpdate
import fr.imacaron.presentationtest.exception.IllegalCallerException
import fr.imacaron.presentationtest.exception.NotFoundException
import io.mockk.*
import io.mockk.impl.annotations.InjectMockKs
import io.mockk.impl.annotations.MockK
import io.mockk.junit5.MockKExtension
import org.assertj.core.api.Assertions.assertThat
import org.assertj.core.api.Assertions.assertThatExceptionOfType
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.extension.ExtendWith
@ExtendWith(MockKExtension::class)
class UserServiceTest(
@MockK(relaxUnitFun = true) private val userRepository: UserRepository
) {
@InjectMockKs
lateinit var userService: UserService
@BeforeEach
fun setup() = MockKAnnotations.init(this)
@Test
fun `Should get a user`() {
val userId = 1L
val user = User(userId, "Denis", 0)
every { userRepository[userId] } returns user
val response = userService.getUser(userId)
assertThat(response).isEqualTo(user)
}
@Test
fun `Should not get a user`() {
val userId = -1L
every { userRepository[userId] } returns null
val response = userService.getUser(userId)
assertThat(response).isNull()
}
@Test
fun `Should not update non-existent user`() {
val userId = -1L
val update = UserUpdate("Zöé", 0)
val caller = User(1, "Denis", 1)
every { userRepository[userId] } returns null
val response = userService.with(caller).updateUser(userId, update)
assertThat(response.isSuccess).isFalse()
assertThat(response.exceptionOrNull()).isNotNull().isExactlyInstanceOf(NotFoundException::class.java)
}
@Test
fun `Should not update user with greater scope`() {
val userId = 2L
val update = UserUpdate("Zöé", 0)
val userToUpdate = User(userId, "Zoé", 5)
val caller = User(1, "Denis", 1)
every { userRepository[userId] } returns userToUpdate
val result = userService.with(caller).updateUser(userId, update)
assertThat(result.isSuccess).isFalse()
assertThat(result.exceptionOrNull())
.isNotNull()
.isExactlyInstanceOf(IllegalCallerException::class.java)
}
@Test
fun `Should not update user with a new scope greater`() {
val userId = 2L
val update = UserUpdate("Zöé", 5)
val userToUpdate = User(userId, "Zoé", 0)
val caller = User(1, "Denis", 1)
every { userRepository[userId] } returns userToUpdate
val result = userService.with(caller).updateUser(userId, update)
assertThat(result.isSuccess).isFalse()
assertThat(result.exceptionOrNull())
.isNotNull()
.isExactlyInstanceOf(IllegalCallerException::class.java)
}
@Test
fun `Should throw with no caller`() {
val userId = 2L
val update = UserUpdate("Zöé", 10)
assertThatExceptionOfType(IllegalCallerException::class.java).isThrownBy {
userService.updateUser(userId, update)
}.withMessage("Caller must be set using with function")
}
@Test
fun `Should update user`() {
val userId = 2L
val update = UserUpdate("Zöé", 1)
val userToUpdate = User(userId, "Zoé", 0)
val caller = User(1, "Denis", 1)
val updatedUser = User(userId, "Zöé", 1)
every { userRepository[userId] } returns userToUpdate
val result = userService.with(caller).updateUser(userId, update)
assertThat(result.isSuccess).isTrue()
assertThat(result.getOrNull())
.isNotNull()
.isEqualTo(updatedUser)
verify(exactly = 1) { userRepository[userId] }
verify(exactly = 1) { userRepository[userId] = updatedUser }
confirmVerified(userRepository)
}
@Test
fun `Should not create user with same name`() {
val caller = User(1, "Denis", 1)
val userName = "Zoé"
val userToCreate = UserCreation(userName, 1)
val user = User(0, userName, 1)
every { userRepository[userName] } returns user
val result = userService.with(caller).createUser(userToCreate)
assertThat(result.isSuccess).isFalse()
assertThat(result.exceptionOrNull())
.isNotNull()
.isExactlyInstanceOf(IllegalArgumentException::class.java)
}
@Test
fun `Should not create user with higher scope`() {
val caller = User(1, "Denis", 1)
val userToCreate = UserCreation("Zoé", 10)
every { userRepository[any() as String] } returns null
val result = userService.with(caller).createUser(userToCreate)
assertThat(result.isSuccess).isFalse()
assertThat(result.exceptionOrNull())
.isNotNull()
.isExactlyInstanceOf(IllegalCallerException::class.java)
}
@Test
fun `Should throw with no caller on creation`() {
val userToCreate = UserCreation("Zoé", 10)
assertThatExceptionOfType(IllegalCallerException::class.java).isThrownBy {
userService.createUser(userToCreate)
}.withMessage("Caller must be set using with function")
}
@Test
fun `Should create user`() {
val caller = User(1, "Denis", 1)
val userToCreate = UserCreation("Zoé", 1)
val createdUser = User(2, "Zoé", 1)
every { userRepository[any() as String] } returns null
every { userRepository.lastId } returns 2
val result = userService.with(caller).createUser(userToCreate)
assertThat(result.isSuccess).isTrue()
assertThat(result.getOrNull())
.isNotNull()
.isEqualTo(createdUser)
verify(exactly = 1) { userRepository += any() }
verify { userRepository[any() as String] }
verify { userRepository.lastId }
confirmVerified(userRepository)
}
@Test
fun `Should not delete user without caller`() {
val userId = 1L
assertThatExceptionOfType(IllegalCallerException::class.java).isThrownBy {
userService.deleteUser(userId)
}.withMessage("Caller must be set set using with function")
}
@Test
fun `Should not delete user not found`() {
val caller = User(1, "Denis", 1)
val userId = 2L
every { userRepository[userId] } returns null
val result = userService.with(caller).deleteUser(userId)
assertThat(result.isSuccess).isFalse()
assertThat(result.exceptionOrNull()).isNotNull()
.isExactlyInstanceOf(NotFoundException::class.java)
verify(exactly = 1) { userRepository[userId] }
verify(exactly = 0) { userRepository.delete(userId) }
confirmVerified(userRepository)
}
@Test
fun `Should not delete user with higher scope`() {
val caller = User(1, "Denis", 1)
val userId = 2L
val user = User(userId, "Zoé", 2)
every { userRepository[userId] } returns user
val result = userService.with(caller).deleteUser(userId)
assertThat(result.isSuccess).isFalse()
assertThat(result.exceptionOrNull()).isNotNull()
.isExactlyInstanceOf(IllegalCallerException::class.java)
verify { userRepository[userId] }
verify(exactly = 0) { userRepository.delete(userId) }
}
@Test
fun `Should delete user`() {
val caller = User(1, "Denis", 1)
val userId = 2L
val user = User(userId, "Zoé", 1)
every { userRepository[userId] } returns user
every { userRepository.delete(userId) } returns Result.success(user)
val result = userService.with(caller).deleteUser(userId)
assertThat(result.isSuccess).isTrue()
assertThat(result.getOrNull()).isNotNull()
.isEqualTo(user)
}
} | presentation-test/src/test/kotlin/fr/imacaron/presentationtest/unit/UserServiceTest.kt | 3983198917 |
package fr.imacaron.presentationtest.integration
import fr.imacaron.presentationtest.core.service.UserService
import fr.imacaron.presentationtest.core.type.User
import fr.imacaron.presentationtest.core.type.UserCreation
import fr.imacaron.presentationtest.core.type.UserUpdate
import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
class UserServiceTest {
private val userRepository = InMemoryUserRepository()
private val userService = UserService(userRepository)
private val caller = User(1, "Denis", 1)
@BeforeEach
fun setup() {
userRepository.clear()
userRepository += UserCreation(caller.name, caller.scope)
}
@Test
fun `Should get existing user`() {
val result = userService.getUser(1)
assertThat(result).isNotNull()
.isEqualTo(caller)
}
@Test
fun `Should not get non-existent user`() {
val result = userService.getUser(2)
assertThat(result).isNull()
}
@Test
fun `Should get newly added user`() {
val user = User(2, "Zoé", 1)
val result1 = userService.getUser(user.id)
userService.with(caller).createUser(UserCreation(user.name, user.scope))
val result2 = userService.getUser(user.id)
assertThat(result1).isNull()
assertThat(result2).isNotNull()
.isEqualTo(user)
}
@Test
fun `Should get updated user`() {
val user = User(2, "Zoé", 1)
val updatedUser = User(2, "Zöé", 0)
userService.with(caller).createUser(UserCreation(user.name, user.scope))
val result1 = userService.getUser(user.id)
userService.with(caller).updateUser(user.id, UserUpdate(updatedUser.name, updatedUser.scope))
val result2 = userService.getUser(user.id)
assertThat(result1).isNotNull()
.isEqualTo(user)
assertThat(result2).isNotNull()
.isEqualTo(updatedUser)
}
@Test
fun `Should not get deleted user`() {
val user = User(2, "Zoé", 1)
userService.with(caller).createUser(UserCreation(user.name, user.scope))
val result1 = userService.getUser(user.id)
val result2 = userService.with(caller).deleteUser(user.id)
val result3 = userService.getUser(user.id)
assertThat(result1).isNotNull()
.isEqualTo(user)
assertThat(result2.isSuccess).isTrue()
assertThat(result2.getOrNull()).isNotNull()
.isEqualTo(user)
assertThat(result3).isNull()
}
} | presentation-test/src/test/kotlin/fr/imacaron/presentationtest/integration/UserServiceTest.kt | 1528730446 |
package fr.imacaron.presentationtest.integration
import fr.imacaron.presentationtest.core.port.UserRepository
import fr.imacaron.presentationtest.core.type.User
import fr.imacaron.presentationtest.core.type.UserCreation
import fr.imacaron.presentationtest.exception.NotFoundException
import fr.imacaron.presentationtest.sql.SQLUserRepository
import fr.imacaron.presentationtest.sql.users
import fr.imacaron.presentationtest.utils.MariaDBContainers
import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.TestInstance
import org.ktorm.dsl.eq
import org.ktorm.entity.add
import org.ktorm.entity.find
import org.testcontainers.junit.jupiter.Testcontainers
@Testcontainers
class SqlUserRepositoryTest: MariaDBContainers() {
@Test
fun `Should save in database`() {
val user = User(1, "Denis", 1)
val userToAdd = UserCreation(user.name, user.scope)
userRepository += userToAdd
val dbUser = db.users.find { it.id eq user.id }?.let { User(it.id, it.name, it.scope) }
assertThat(dbUser).isNotNull()
.isEqualTo(user)
}
@Test
fun `Should retrieve from database`() {
val user = User(1, "Denis", 1)
db.users.add(SQLUserRepository.UserEntity{
id = user.id
name = user.name
scope = user.scope
})
val dbUser = userRepository[user.id]
assertThat(dbUser).isNotNull()
.isEqualTo(user)
}
@Test
fun `Should not get unsaved user`() {
val dbUser = userRepository[1]
assertThat(dbUser).isNull()
}
@Test
fun `Should delete user`() {
val user = User(1, "Denis", 1)
db.users.add(SQLUserRepository.UserEntity {
id = user.id
name = user.name
scope = user.scope
})
val result = userRepository.delete(user.id)
assertThat(result.isSuccess).isTrue()
assertThat(result.getOrNull()).isNotNull()
.isEqualTo(user)
}
@Test
fun `Should not delete not found user`() {
val result = userRepository.delete(1)
assertThat(result.isSuccess).isFalse()
assertThat(result.exceptionOrNull()).isNotNull()
.isExactlyInstanceOf(NotFoundException::class.java)
}
} | presentation-test/src/test/kotlin/fr/imacaron/presentationtest/integration/SqlUserRepositoryTest.kt | 2768018605 |
package fr.imacaron.presentationtest.integration
import fr.imacaron.presentationtest.core.port.UserRepository
import fr.imacaron.presentationtest.core.type.User
import fr.imacaron.presentationtest.core.type.UserCreation
import fr.imacaron.presentationtest.exception.NotFoundException
class InMemoryUserRepository: UserRepository() {
private val map = mutableMapOf<Long, User>()
override fun get(id: Long): User? = map[id]
override fun set(id: Long, user: User) {
map[id] = user
}
override fun delete(id: Long): Result<User> {
return map.remove(id)?.let {
Result.success(it)
} ?: Result.failure(NotFoundException("User not found"))
}
override fun get(name: String): User? = map.values.find { it.name == name }
override fun plusAssign(user: UserCreation) {
map[lastId + 1] = User(lastId + 1, user.name, user.scope)
lastId++
}
fun clear() {
map.clear()
lastId = 0
}
} | presentation-test/src/test/kotlin/fr/imacaron/presentationtest/integration/InMemoryUserRepository.kt | 4133393455 |
package fr.imacaron.presentationtest.utils
import fr.imacaron.presentationtest.core.port.UserRepository
import fr.imacaron.presentationtest.sql.SQLUserRepository
import fr.imacaron.presentationtest.sql.users
import org.junit.jupiter.api.BeforeAll
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.TestInstance
import org.ktorm.database.Database
import org.ktorm.entity.clear
import org.ktorm.support.mysql.MySqlDialect
import org.testcontainers.containers.MariaDBContainer
import org.testcontainers.junit.jupiter.Container
import org.testcontainers.junit.jupiter.Testcontainers
@Testcontainers
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
abstract class MariaDBContainers {
protected lateinit var db: Database
protected lateinit var userRepository: UserRepository
companion object {
@Container
val database: MariaDBContainer<*> = MariaDBContainer("mariadb:10.2")
.withDatabaseName("test")
.withUsername("root")
.withPassword("")
.withInitScript("init-base.sql")
}
@BeforeAll
fun connectToDatabase() {
db = Database.connect(
database.jdbcUrl,
database.driverClassName,
database.username,
database.password,
dialect = MySqlDialect()
)
userRepository = SQLUserRepository(db)
}
@BeforeEach
fun cleanDataBase() {
db.users.clear()
}
} | presentation-test/src/test/kotlin/fr/imacaron/presentationtest/utils/MariaDBContainers.kt | 4064583447 |
package fr.imacaron.presentationtest.end2end
import fr.imacaron.presentationtest.core.type.User
import fr.imacaron.presentationtest.core.type.UserCreation
import fr.imacaron.presentationtest.core.type.UserUpdate
import fr.imacaron.presentationtest.module
import fr.imacaron.presentationtest.sql.entity
import fr.imacaron.presentationtest.sql.users
import fr.imacaron.presentationtest.utils.MariaDBContainers
import io.ktor.client.*
import io.ktor.client.call.*
import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
import io.ktor.client.request.*
import io.ktor.client.request.get
import io.ktor.http.*
import io.ktor.serialization.kotlinx.json.*
import io.ktor.server.config.*
import io.ktor.server.testing.*
import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.Test
import org.ktorm.entity.add
import org.testcontainers.junit.jupiter.Testcontainers
@Testcontainers
class UserRouterTest: MariaDBContainers() {
fun testApp(test: suspend ApplicationTestBuilder.(client: HttpClient) -> Unit) = testApplication {
environment {
config = MapApplicationConfig(
"db.url" to database.jdbcUrl,
"db.user" to database.username,
"db.password" to database.password
)
}
application {
module()
}
val client = createClient {
install(ContentNegotiation) {
json()
}
}
test(client)
}
@Test
fun `Should not get self`() = testApp { client ->
val response = client.get("/user/me") {
bearerAuth("1")
}
assertThat(response.status).isEqualTo(HttpStatusCode.NotFound)
}
@Test
fun `Should get self`() = testApp { client ->
val user = User(0, "Denis", 1)
db.users.add(user.entity)
val response = client.get("/user/me") {
bearerAuth(user.id.toString())
}
assertThat(response.status).isEqualTo(HttpStatusCode.OK)
assertThat(response.body<User>()).isEqualTo(user)
}
@Test
fun `Should get created user`() = testApp { client ->
val caller = User(0, "Denis", 1)
val userToCreate = UserCreation("Zoé", 1)
db.users.add(caller.entity)
val response = client.post("/user") {
contentType(ContentType.Application.Json)
setBody(userToCreate)
bearerAuth(caller.id.toString())
}
assertThat(response.status).isEqualTo(HttpStatusCode.Created)
assertThat(response.body<User>()).extracting("name", "scope").containsExactly(userToCreate.name, userToCreate.scope)
}
@Test
fun `Should delete user`() = testApp { client ->
val caller = User(0, "Denis", 1)
val user = User(1, "Zoé", 1)
db.users.add(caller.entity)
db.users.add(user.entity)
val response = client.delete("/user/${user.id}") {
bearerAuth(caller.id.toString())
}
assertThat(response.status).isEqualTo(HttpStatusCode.NoContent)
val response2 = client.get("/user/${user.id}") {
bearerAuth(caller.id.toString())
}
assertThat(response2.status).isEqualTo(HttpStatusCode.NotFound)
}
@Test
fun `Should update user`() = testApp { client ->
val caller = User(0, "Denis", 1)
val user = User(1, "Zoé", 1)
val updateUser = UserUpdate("Zöé", 0)
val userUpdated = User(user.id, updateUser.name, updateUser.scope)
db.users.add(caller.entity)
db.users.add(user.entity)
val response = client.put("/user/${user.id}") {
bearerAuth(caller.id.toString())
contentType(ContentType.Application.Json)
setBody(updateUser)
}
assertThat(response.status).isEqualTo(HttpStatusCode.OK)
assertThat(response.body<User>()).isEqualTo(userUpdated)
}
} | presentation-test/src/test/kotlin/fr/imacaron/presentationtest/end2end/UserRouterTest.kt | 3264660407 |
package fr.imacaron.presentationtest.core.type
import kotlinx.serialization.Serializable
@Serializable
data class UserCreation(
val name: String,
val scope: Int
)
| presentation-test/src/main/kotlin/fr/imacaron/presentationtest/core/type/UserCreation.kt | 3106489499 |
package fr.imacaron.presentationtest.core.type
import kotlinx.serialization.Serializable
@Serializable
data class UserUpdate(
val name: String,
val scope: Int
)
| presentation-test/src/main/kotlin/fr/imacaron/presentationtest/core/type/UserUpdate.kt | 3676658163 |
package fr.imacaron.presentationtest.core.type
import kotlinx.serialization.Serializable
@Serializable
data class User(
val id: Long,
val name: String,
val scope: Int
)
| presentation-test/src/main/kotlin/fr/imacaron/presentationtest/core/type/User.kt | 4248914139 |
package fr.imacaron.presentationtest.core.service
import fr.imacaron.presentationtest.core.port.UserRepository
import fr.imacaron.presentationtest.core.type.User
import fr.imacaron.presentationtest.core.type.UserCreation
import fr.imacaron.presentationtest.core.type.UserUpdate
import fr.imacaron.presentationtest.exception.IllegalCallerException
import fr.imacaron.presentationtest.exception.NotFoundException
class UserService(
private val userRepository: UserRepository
) {
private var caller: User? = null
fun with(user: User): UserService {
caller = user
return this
}
fun getUser(id: Long): User? = userRepository[id]
fun updateUser(id: Long, update: UserUpdate): Result<User> {
val caller = this.caller ?: throw IllegalCallerException("Caller must be set using with function")
val user = userRepository[id] ?: return Result.failure(NotFoundException("User not found"))
if(caller.scope < user.scope || caller.scope < update.scope) {
return Result.failure(IllegalCallerException("User have not the right to do that"))
}
val updatedUser = user.copy(name = update.name, scope = update.scope)
userRepository[id] = updatedUser
return Result.success(updatedUser)
}
fun createUser(user: UserCreation): Result<User> {
val caller = this.caller ?: throw IllegalCallerException("Caller must be set using with function")
if(userRepository[user.name] != null) {
return Result.failure(IllegalArgumentException("User with name \"${user.name}\" already exist"))
}
if(caller.scope < user.scope) {
return Result.failure(IllegalCallerException("User have not the right to do that"))
}
userRepository += user
return Result.success(User(userRepository.lastId, user.name, user.scope))
}
fun deleteUser(id: Long): Result<User> {
val caller = this.caller ?: throw IllegalCallerException("Caller must be set set using with function")
val user = userRepository[id] ?: return Result.failure(NotFoundException("User not found"))
if(caller.scope < user.scope) {
return Result.failure(IllegalCallerException("User have not right to do that"))
}
if(caller == user) {
return Result.failure(IllegalCallerException("User cannot delete himself"))
}
userRepository.delete(id)
return Result.success(user)
}
} | presentation-test/src/main/kotlin/fr/imacaron/presentationtest/core/service/UserService.kt | 677339320 |
package fr.imacaron.presentationtest.core.port
import fr.imacaron.presentationtest.core.type.User
import fr.imacaron.presentationtest.core.type.UserCreation
abstract class UserRepository {
var lastId: Long = 0
protected set
abstract operator fun get(id: Long): User?
abstract operator fun set(id: Long, user: User)
abstract fun delete(id: Long): Result<User>
abstract operator fun get(name: String): User?
abstract operator fun plusAssign(user: UserCreation)
} | presentation-test/src/main/kotlin/fr/imacaron/presentationtest/core/port/UserRepository.kt | 3637760259 |
package fr.imacaron.presentationtest
import fr.imacaron.presentationtest.core.port.UserRepository
import fr.imacaron.presentationtest.core.service.UserService
import fr.imacaron.presentationtest.core.type.User
import fr.imacaron.presentationtest.router.UserRouter
import fr.imacaron.presentationtest.sql.SQLUserRepository
import io.ktor.resources.*
import io.ktor.serialization.kotlinx.json.*
import io.ktor.server.application.*
import io.ktor.server.auth.*
import io.ktor.server.netty.EngineMain
import io.ktor.server.plugins.callloging.*
import io.ktor.server.plugins.contentnegotiation.*
import io.ktor.server.resources.Resources
import org.ktorm.database.Database
import org.ktorm.support.mysql.MySqlDialect
import org.slf4j.event.Level
fun main(args: Array<String>) {
EngineMain.main(args)
}
fun Application.module() {
installAuth()
installContentNegotiation()
installCallLogging()
installResources()
val database = database()
val userRepository = SQLUserRepository(database)
val userService = UserService(userRepository)
UserRouter(userService).apply { [email protected]() }
}
const val authName = "auth"
fun Application.database() = Database.connect(
environment.config.property("db.url").getString(),
driver = "org.mariadb.jdbc.Driver",
dialect = MySqlDialect(),
user = environment.config.property("db.user").getString(),
password = environment.config.property("db.password").getString()
)
fun Application.installAuth() {
install(Authentication) {
bearer(authName) {
realm = "Présentation Test"
authenticate { tokenCredential ->
UserIdPrincipal(tokenCredential.token)
}
}
}
}
fun Application.installContentNegotiation() {
install(ContentNegotiation) {
json()
}
}
fun Application.installCallLogging() {
install(CallLogging) {
level = Level.INFO
}
}
fun Application.installResources() {
install(Resources)
} | presentation-test/src/main/kotlin/fr/imacaron/presentationtest/Main.kt | 3384527547 |
package fr.imacaron.presentationtest.exception
class NotFoundException(message: String): Exception(message) {
} | presentation-test/src/main/kotlin/fr/imacaron/presentationtest/exception/NotFoundException.kt | 3986369724 |
package fr.imacaron.presentationtest.exception
class IllegalCallerException(message: String): Exception(message) | presentation-test/src/main/kotlin/fr/imacaron/presentationtest/exception/IllegalCallerException.kt | 3102594676 |
package fr.imacaron.presentationtest.router
import fr.imacaron.presentationtest.authName
import fr.imacaron.presentationtest.core.service.UserService
import fr.imacaron.presentationtest.core.type.UserCreation
import fr.imacaron.presentationtest.core.type.UserUpdate
import fr.imacaron.presentationtest.exception.IllegalCallerException
import fr.imacaron.presentationtest.exception.NotFoundException
import io.ktor.http.*
import io.ktor.resources.*
import io.ktor.server.application.*
import io.ktor.server.auth.*
import io.ktor.server.request.*
import io.ktor.server.resources.*
import io.ktor.server.response.*
import io.ktor.server.routing.*
import io.ktor.server.resources.put
import io.ktor.server.resources.post
class UserRouter(
private val userService: UserService,
) {
fun Application.route() {
routing {
authenticate(authName) {
getSelf()
getUser()
updateUser()
createUser()
deleteUser()
}
}
}
private fun Route.getSelf() {
get<User.Me> {
val user = userService.getUser(call.principal<UserIdPrincipal>()!!.name.toLong()) ?: return@get
call.respond(user)
}
}
private fun Route.getUser() {
get<User.Id> {
val user = userService.getUser(it.id) ?: return@get
call.respond(user)
}
}
private fun Route.updateUser() {
put<User.Id> { userId ->
val update: UserUpdate = call.receive()
val caller = userService.getUser(call.principal<UserIdPrincipal>()!!.name.toLong()) ?: run {
call.respond(HttpStatusCode.Unauthorized)
return@put
}
val result = userService.with(caller).updateUser(userId.id, update)
result.onSuccess {
call.respond(it)
}
result.onFailure {
when(it) {
is NotFoundException -> call.respond(HttpStatusCode.NotFound)
is IllegalCallerException -> call.respond(HttpStatusCode.Forbidden)
}
}
}
}
private fun Route.createUser() {
post<User> {
val creation: UserCreation = call.receive()
val caller = userService.getUser(call.principal<UserIdPrincipal>()!!.name.toLong()) ?: run {
call.respond(HttpStatusCode.Unauthorized)
return@post
}
val result = userService.with(caller).createUser(creation)
result.onSuccess {
call.respond(HttpStatusCode.Created, it)
}
result.onFailure {
when(it) {
is NotFoundException -> call.respond(HttpStatusCode.NotFound)
is IllegalCallerException -> call.respond(HttpStatusCode.Unauthorized)
is IllegalArgumentException -> call.respond(HttpStatusCode.BadRequest)
}
}
}
}
private fun Route.deleteUser() {
delete<User.Id> {
val caller = userService.getUser(call.principal<UserIdPrincipal>()!!.name.toLong()) ?: run {
call.respond(HttpStatusCode.Unauthorized)
return@delete
}
userService.with(caller).deleteUser(it.id).onSuccess {
call.respond(HttpStatusCode.NoContent)
}.onFailure { failure ->
when(failure) {
is NotFoundException -> call.respond(HttpStatusCode.NotFound)
is IllegalCallerException -> call.respond(HttpStatusCode.Forbidden, failure.message ?: "")
}
}
}
}
@Resource("/user")
class User {
@Resource("me")
class Me(val parent: User = User())
@Resource("{id}")
class Id(val parent: User = User(), val id: Long)
}
} | presentation-test/src/main/kotlin/fr/imacaron/presentationtest/router/UserRouter.kt | 1499085358 |
package fr.imacaron.presentationtest.sql
import fr.imacaron.presentationtest.core.port.UserRepository
import fr.imacaron.presentationtest.core.type.User
import fr.imacaron.presentationtest.core.type.UserCreation
import fr.imacaron.presentationtest.exception.NotFoundException
import org.ktorm.database.Database
import org.ktorm.dsl.eq
import org.ktorm.entity.*
import org.ktorm.schema.Table
import org.ktorm.schema.int
import org.ktorm.schema.long
import org.ktorm.schema.varchar
class SQLUserRepository(private val db: Database): UserRepository() {
init {
lastId = db.users.maxBy { it.id } ?: 0
}
override fun get(id: Long): User? {
return db.users.find { it.id eq id }?.let { User(it) }
}
override fun set(id: Long, user: User) {
db.users.find { it.id eq id }?.let {
it.name = user.name
it.scope = user.scope
it.flushChanges()
} ?: throw NotFoundException("User not found")
}
override fun delete(id: Long): Result<User> {
val user = db.users.find { it.id eq id } ?: return Result.failure(NotFoundException("User not found"))
user.delete()
return Result.success(User(user))
}
override fun get(name: String): User? {
return db.users.find { it.name eq name }?.let { User(it) }
}
override fun plusAssign(user: UserCreation) {
val userEntity = UserEntity {
id = lastId + 1
name = user.name
scope = user.scope
}
db.users.add(userEntity)
}
object Users: Table<UserEntity>("USERS") {
val id = long("id").primaryKey().bindTo { it.id }
val name = varchar("name").bindTo { it.name }
val scope = int("scope").bindTo { it.scope }
}
interface UserEntity: Entity<UserEntity> {
var id: Long
var name: String
var scope: Int
companion object: Entity.Factory<UserEntity>()
}
}
operator fun User.Companion.invoke(entity: SQLUserRepository.UserEntity) = User(entity.id, entity.name, entity.scope)
val User.entity
get() = let { user ->
SQLUserRepository.UserEntity {
id = user.id
name = user.name
scope = user.scope
}
}
val Database.users get() = this.sequenceOf(SQLUserRepository.Users)
| presentation-test/src/main/kotlin/fr/imacaron/presentationtest/sql/SQLUserRepository.kt | 3482446105 |
import com.anandbose.BundlePath
import com.anandbose.ProgramArguments
import com.anandbose.TRACK_PRODUCTION
import com.anandbose.runWithArguments
import java.io.File
import kotlin.test.Test
class BundleUploadTest {
@Test
fun uploadBundle() {
runWithArguments(
ProgramArguments(
serviceAccountFile = File("/home/anandbose/Downloads/pc-api-7435836948364980037-995-7caf1aa2f08e.json"),
applicationName = "com.anandbose.blogapp",
appPath = BundlePath(File("/home/anandbose/AndroidStudioProjects/blog-android-app/app/build/outputs/bundle/release/app-release.aab")),
track = TRACK_PRODUCTION,
)
)
}
} | gplayup/src/test/kotlin/BundleUploadTest.kt | 1090506319 |
package com.anandbose
import java.io.File
sealed interface AppPath
@JvmInline value class ApkPath(val file: File): AppPath
@JvmInline value class BundlePath(val file: File): AppPath
sealed interface ArgParseResult
data class ProgramArguments(
val serviceAccountFile: File,
val applicationName: String,
val appPath: AppPath,
val track: String,
val releaseNotes: String? = null,
): ArgParseResult
@JvmInline
value class ArgumentError(val error: String): ArgParseResult
private const val STATE_EXPECT_ARG_KEY = 0
private const val STATE_EXPECT_SERVICE_ACCOUNT_PATH = 1
private const val STATE_EXPECT_APPLICATION_NAME = 2
private const val STATE_EXPECT_BUNDLE_PATH = 3
private const val STATE_EXPECT_APK_PATH = 4
private const val STATE_EXPECT_TRACK = 5
private const val STATE_EXPECT_RELEASE_NOTES = 6
fun parseArgs(args: Array<String>): ArgParseResult {
var state = STATE_EXPECT_ARG_KEY
var serviceAccountFilePath: String? = null
var applicationName: String? = null
var bundlePath: String? = null
var apkPath: String? = null
var track: String? = null
var releaseNotes: String? = null
for (arg in args) {
when (state) {
STATE_EXPECT_ARG_KEY -> {
state = when (arg) {
ARG_SERVICE_ACCOUNT -> STATE_EXPECT_SERVICE_ACCOUNT_PATH
ARG_APPLICATION_NAME -> STATE_EXPECT_APPLICATION_NAME
ARG_APK_PATH -> STATE_EXPECT_APK_PATH
ARG_BUNDLE_PATH -> STATE_EXPECT_BUNDLE_PATH
ARG_TRACK -> STATE_EXPECT_TRACK
ARG_RELEASE_NOTES -> STATE_EXPECT_RELEASE_NOTES
else -> return ArgumentError("Unknown switch: $arg")
}
continue
}
STATE_EXPECT_SERVICE_ACCOUNT_PATH -> {
serviceAccountFilePath = arg
state = STATE_EXPECT_ARG_KEY
continue
}
STATE_EXPECT_APPLICATION_NAME -> {
applicationName = arg
state = STATE_EXPECT_ARG_KEY
continue
}
STATE_EXPECT_BUNDLE_PATH -> {
bundlePath = arg
state = STATE_EXPECT_ARG_KEY
continue
}
STATE_EXPECT_APK_PATH -> {
apkPath = arg
state = STATE_EXPECT_ARG_KEY
continue
}
STATE_EXPECT_TRACK -> {
track = arg
state = STATE_EXPECT_ARG_KEY
continue
}
STATE_EXPECT_RELEASE_NOTES -> {
releaseNotes = arg
state = STATE_EXPECT_ARG_KEY
continue
}
}
}
val serviceAccountFile = if (serviceAccountFilePath != null) {
File(serviceAccountFilePath)
} else {
return ArgumentError("Service account file is required for authentication.")
}
if (!serviceAccountFile.exists()) {
return ArgumentError("Service account file $serviceAccountFilePath does not exist.")
}
if (!serviceAccountFile.canRead()) {
return ArgumentError("Service account file $serviceAccountFilePath cannot be read.")
}
if (applicationName.isNullOrBlank()) {
return ArgumentError("Application package identifier is required.")
}
val appPath = when {
bundlePath != null -> {
val file = File(bundlePath)
if (!file.exists()) {
return ArgumentError("Bundle path $bundlePath does not exist.")
}
if (!file.canRead()) {
return ArgumentError("Bundle path $bundlePath cannot be read.")
}
BundlePath(file)
}
apkPath != null -> {
val file = File(apkPath)
if (!file.exists()) {
return ArgumentError("APK path $bundlePath does not exist.")
}
if (!file.canRead()) {
return ArgumentError("APK path $bundlePath cannot be read.")
}
ApkPath(file)
}
else -> return ArgumentError("Either APK or App Bundle is required.")
}
if (track == null) {
return ArgumentError("Track is required.")
}
return ProgramArguments(
serviceAccountFile = serviceAccountFile,
applicationName = applicationName,
appPath = appPath,
track = track,
releaseNotes = releaseNotes,
)
} | gplayup/src/main/kotlin/ArgParser.kt | 42504279 |
package com.anandbose
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport
import com.google.api.client.http.FileContent
import com.google.api.client.json.gson.GsonFactory
import com.google.api.services.androidpublisher.AndroidPublisher
import com.google.api.services.androidpublisher.AndroidPublisherScopes
import com.google.api.services.androidpublisher.model.LocalizedText
import com.google.api.services.androidpublisher.model.Track
import com.google.api.services.androidpublisher.model.TrackRelease
import com.google.auth.http.HttpCredentialsAdapter
import com.google.auth.oauth2.GoogleCredentials
fun main(args: Array<String>) {
when (val argParseResult = parseArgs(args)) {
is ArgumentError -> {
println("⛔ ${argParseResult.error}")
printHelp()
}
is ProgramArguments -> runWithArguments(argParseResult)
}
}
fun printHelp() {
println("""
Usage:
$APP_NAME $ARG_SERVICE_ACCOUNT ./path/to/service-account.json
$ARG_APPLICATION_NAME com.example.app
[$ARG_BUNDLE_PATH ./path/to/bundle.aab | $ARG_APK_PATH ./path/to/apkfile.apk]
$ARG_TRACK 'production'
$ARG_RELEASE_NOTES 'release notes'
""".trimIndent())
}
fun runWithArguments(args: ProgramArguments) {
val credential = GoogleCredentials.fromStream(args.serviceAccountFile.inputStream())
.createScoped(AndroidPublisherScopes.ANDROIDPUBLISHER)
val token = credential.refreshAccessToken()?.tokenValue
if (token != null) {
if (LOG_ACCESS_TOKEN) {
println("⚠\uFE0F⚠\uFE0F⚠\uFE0F BEGIN ACCESS TOKEN ⚠\uFE0F⚠\uFE0F⚠\uFE0F")
println(token)
println("⚠\uFE0F⚠\uFE0F⚠\uFE0F END ACCESS TOKEN ⚠\uFE0F⚠\uFE0F⚠\uFE0F")
}
println("✅ Authenticated with Google Play")
uploadToGooglePlay(args, credential)
} else {
println("⛔ Authentication failed")
}
}
fun uploadToGooglePlay(args: ProgramArguments, credentials: GoogleCredentials) {
val transport = GoogleNetHttpTransport.newTrustedTransport()
val jsonFactory = GsonFactory.getDefaultInstance()
val requestInitializer = HttpCredentialsAdapter(credentials)
val publisher = AndroidPublisher.Builder(transport, jsonFactory, requestInitializer)
.setApplicationName(args.applicationName)
.build()
val edits = publisher.edits()
val insert = edits.insert(args.applicationName, null)
val appEdit = insert.execute()
val editId = appEdit.id
println("✍\uFE0F Created Edit ID: $editId")
val versionCode = when (val app = args.appPath) {
is ApkPath -> {
println("\uD83D\uDCE6 Uploading APK")
val apkFile = FileContent(MIME_TYPE_APK, app.file)
val upload = edits.apks()
.upload(args.applicationName, editId, apkFile)
val apk = upload.execute()
println("\uD83D\uDE80 Uploaded APK (version code: ${apk.versionCode})")
apk.versionCode
}
is BundlePath -> {
println("\uD83D\uDCE6 Uploading App Bundle")
val bundleFile = FileContent(MIME_TYPE_BUNDLE, app.file)
val upload = edits.bundles()
.upload(args.applicationName, editId, bundleFile)
val bundle = upload.execute()
println("\uD83D\uDE80 Uploaded App Bundle (version code: ${bundle.versionCode})")
bundle.versionCode
}
}
val update = edits.tracks()
.update(
args.applicationName,
editId,
args.track,
Track().setReleases(
mutableListOf(
TrackRelease()
.setVersionCodes(mutableListOf(versionCode.toLong()))
.setStatus("completed")
.setReleaseNotes(
mutableListOf(
LocalizedText()
.setLanguage("en-US")
.setText(args.releaseNotes ?: "")
)
)
)
)
)
val track = update.execute()
println("✅ Track ${track.track} has been updated.")
val commit = edits.commit(args.applicationName, editId)
val appEditFinal = commit.execute()
println("✨ App (Edit ID${appEditFinal.id}) has been committed to ${track.track} track.")
} | gplayup/src/main/kotlin/Main.kt | 2850557559 |
package com.anandbose
const val LOG_ACCESS_TOKEN = false
const val APP_NAME = "gplayup"
const val ARG_SERVICE_ACCOUNT = "--service-account"
const val ARG_APPLICATION_NAME = "--application-name"
const val ARG_BUNDLE_PATH = "--bundle-path"
const val ARG_APK_PATH = "--apk-path"
const val ARG_TRACK = "--track"
const val ARG_RELEASE_NOTES = "--release-notes"
const val MIME_TYPE_APK = "application/vnd.android.package-archive"
const val MIME_TYPE_BUNDLE = "application/octet-stream"
const val TRACK_ALPHA = "alpha"
const val TRACK_BETA = "beta"
const val TRACK_PRODUCTION = "production"
const val TRACK_QA = "qa" | gplayup/src/main/kotlin/Constants.kt | 1597027941 |
package com.example.myapplication
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("com.example.myapplication", appContext.packageName)
}
} | seven_navigation712/app/src/androidTest/java/com/example/myapplication/ExampleInstrumentedTest.kt | 1188990709 |
package com.example.myapplication
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)
}
} | seven_navigation712/app/src/test/java/com/example/myapplication/ExampleUnitTest.kt | 2019423820 |
package com.example.myapplication.ui.login
import androidx.lifecycle.Observer
import androidx.lifecycle.ViewModelProvider
import androidx.annotation.StringRes
import androidx.fragment.app.Fragment
import android.os.Bundle
import android.text.Editable
import android.text.TextWatcher
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.view.inputmethod.EditorInfo
import android.widget.Button
import android.widget.EditText
import android.widget.ProgressBar
import android.widget.Toast
import androidx.navigation.fragment.findNavController
import com.example.myapplication.databinding.FragmentLoginBinding
import com.example.myapplication.R
class LoginFragment : Fragment() {
private lateinit var loginViewModel: LoginViewModel
private var _binding: FragmentLoginBinding? = null
// This property is only valid between onCreateView and
// onDestroyView.
private val binding get() = _binding!!
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
_binding = FragmentLoginBinding.inflate(inflater, container, false)
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
loginViewModel = ViewModelProvider(this, LoginViewModelFactory())
.get(LoginViewModel::class.java)
val usernameEditText = binding.username
val passwordEditText = binding.password
val loginButton = binding.login
val loadingProgressBar = binding.loading
loginViewModel.loginFormState.observe(viewLifecycleOwner,
Observer { loginFormState ->
if (loginFormState == null) {
return@Observer
}
loginButton.isEnabled = loginFormState.isDataValid
loginFormState.usernameError?.let {
usernameEditText.error = getString(it)
}
loginFormState.passwordError?.let {
passwordEditText.error = getString(it)
}
})
loginViewModel.loginResult.observe(viewLifecycleOwner,
Observer { loginResult ->
loginResult ?: return@Observer
loadingProgressBar.visibility = View.GONE
loginResult.error?.let {
showLoginFailed(it)
}
loginResult.success?.let {
//updateUiWithUser(it)
val bundle = Bundle()
bundle.putString("key","Some string!")
findNavController().navigate(R.id.action_loginFragment_to_resultFragment, bundle)
}
})
val afterTextChangedListener = object : TextWatcher {
override fun beforeTextChanged(s: CharSequence, start: Int, count: Int, after: Int) {
// ignore
}
override fun onTextChanged(s: CharSequence, start: Int, before: Int, count: Int) {
// ignore
}
override fun afterTextChanged(s: Editable) {
loginViewModel.loginDataChanged(
usernameEditText.text.toString(),
passwordEditText.text.toString()
)
}
}
usernameEditText.addTextChangedListener(afterTextChangedListener)
passwordEditText.addTextChangedListener(afterTextChangedListener)
passwordEditText.setOnEditorActionListener { _, actionId, _ ->
if (actionId == EditorInfo.IME_ACTION_DONE) {
loginViewModel.login(
usernameEditText.text.toString(),
passwordEditText.text.toString()
)
}
false
}
loginButton.setOnClickListener {
loadingProgressBar.visibility = View.VISIBLE
loginViewModel.login(
usernameEditText.text.toString(),
passwordEditText.text.toString()
)
}
}
private fun updateUiWithUser(model: LoggedInUserView) {
val welcome = getString(R.string.welcome) + model.displayName
// TODO : initiate successful logged in experience
val appContext = context?.applicationContext ?: return
Toast.makeText(appContext, welcome, Toast.LENGTH_LONG).show()
}
private fun showLoginFailed(@StringRes errorString: Int) {
val appContext = context?.applicationContext ?: return
Toast.makeText(appContext, errorString, Toast.LENGTH_LONG).show()
}
override fun onDestroyView() {
super.onDestroyView()
_binding = null
}
} | seven_navigation712/app/src/main/java/com/example/myapplication/ui/login/LoginFragment.kt | 56986795 |
package com.example.myapplication.ui.login
/**
* User details post authentication that is exposed to the UI
*/
data class LoggedInUserView(
val displayName: String
//... other data fields that may be accessible to the UI
) | seven_navigation712/app/src/main/java/com/example/myapplication/ui/login/LoggedInUserView.kt | 361465294 |
package com.example.myapplication.ui.login
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import android.util.Patterns
import com.example.myapplication.data.LoginRepository
import com.example.myapplication.data.Result
import com.example.myapplication.R
class LoginViewModel(private val loginRepository: LoginRepository) : ViewModel() {
private val _loginForm = MutableLiveData<LoginFormState>()
val loginFormState: LiveData<LoginFormState> = _loginForm
private val _loginResult = MutableLiveData<LoginResult>()
val loginResult: LiveData<LoginResult> = _loginResult
fun login(username: String, password: String) {
// can be launched in a separate asynchronous job
val result = loginRepository.login(username, password)
if (result is Result.Success) {
_loginResult.value =
LoginResult(success = LoggedInUserView(displayName = result.data.displayName))
} else {
_loginResult.value = LoginResult(error = R.string.login_failed)
}
}
fun loginDataChanged(username: String, password: String) {
if (!isUserNameValid(username)) {
_loginForm.value = LoginFormState(usernameError = R.string.invalid_username)
} else if (!isPasswordValid(password)) {
_loginForm.value = LoginFormState(passwordError = R.string.invalid_password)
} else {
_loginForm.value = LoginFormState(isDataValid = true)
}
}
// A placeholder username validation check
private fun isUserNameValid(username: String): Boolean {
return if (username.contains("@")) {
Patterns.EMAIL_ADDRESS.matcher(username).matches()
} else {
username.isNotBlank()
}
}
// A placeholder password validation check
private fun isPasswordValid(password: String): Boolean {
return password.length > 5
}
} | seven_navigation712/app/src/main/java/com/example/myapplication/ui/login/LoginViewModel.kt | 3836412358 |
package com.example.myapplication.ui.login
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import com.example.myapplication.data.LoginDataSource
import com.example.myapplication.data.LoginRepository
/**
* ViewModel provider factory to instantiate LoginViewModel.
* Required given LoginViewModel has a non-empty constructor
*/
class LoginViewModelFactory : ViewModelProvider.Factory {
@Suppress("UNCHECKED_CAST")
override fun <T : ViewModel> create(modelClass: Class<T>): T {
if (modelClass.isAssignableFrom(LoginViewModel::class.java)) {
return LoginViewModel(
loginRepository = LoginRepository(
dataSource = LoginDataSource()
)
) as T
}
throw IllegalArgumentException("Unknown ViewModel class")
}
} | seven_navigation712/app/src/main/java/com/example/myapplication/ui/login/LoginViewModelFactory.kt | 248019311 |
package com.example.myapplication.ui.login
/**
* Authentication result : success (user details) or error message.
*/
data class LoginResult(
val success: LoggedInUserView? = null,
val error: Int? = null
) | seven_navigation712/app/src/main/java/com/example/myapplication/ui/login/LoginResult.kt | 753580050 |
package com.example.myapplication.ui.login
/**
* Data validation state of the login form.
*/
data class LoginFormState(
val usernameError: Int? = null,
val passwordError: Int? = null,
val isDataValid: Boolean = false
) | seven_navigation712/app/src/main/java/com/example/myapplication/ui/login/LoginFormState.kt | 2335287955 |
package com.example.myapplication
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
}
} | seven_navigation712/app/src/main/java/com/example/myapplication/MainActivity.kt | 665038924 |
package com.example.myapplication
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.Toast
// TODO: Rename parameter arguments, choose names that match
// the fragment initialization parameters, e.g. ARG_ITEM_NUMBER
private const val ARG_PARAM1 = "key"
private const val ARG_PARAM2 = "param2"
/**
* A simple [Fragment] subclass.
* Use the [ResultFragment.newInstance] factory method to
* create an instance of this fragment.
*/
class ResultFragment : Fragment() {
// TODO: Rename and change types of parameters
private var param1: String? = null
private var param2: String? = null
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
arguments?.let {
param1 = it.getString(ARG_PARAM1)
param2 = it.getString(ARG_PARAM2)
}
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
Toast.makeText(context,param1.toString(),Toast.LENGTH_LONG).show()
return inflater.inflate(R.layout.fragment_result, container, false)
}
companion object {
/**
* Use this factory method to create a new instance of
* this fragment using the provided parameters.
*
* @param param1 Parameter 1.
* @param param2 Parameter 2.
* @return A new instance of fragment ResultFragment.
*/
// TODO: Rename and change types and number of parameters
@JvmStatic
fun newInstance(param1: String, param2: String) =
ResultFragment().apply {
arguments = Bundle().apply {
putString(ARG_PARAM1, param1)
putString(ARG_PARAM2, param2)
}
}
}
} | seven_navigation712/app/src/main/java/com/example/myapplication/ResultFragment.kt | 481186400 |
package com.example.myapplication.data
/**
* A generic class that holds a value with its loading status.
* @param <T>
*/
sealed class Result<out T : Any> {
data class Success<out T : Any>(val data: T) : Result<T>()
data class Error(val exception: Exception) : Result<Nothing>()
override fun toString(): String {
return when (this) {
is Success<*> -> "Success[data=$data]"
is Error -> "Error[exception=$exception]"
}
}
} | seven_navigation712/app/src/main/java/com/example/myapplication/data/Result.kt | 2053417758 |
package com.example.myapplication.data
import com.example.myapplication.data.model.LoggedInUser
import java.io.IOException
/**
* Class that handles authentication w/ login credentials and retrieves user information.
*/
class LoginDataSource {
fun login(username: String, password: String): Result<LoggedInUser> {
try {
// TODO: handle loggedInUser authentication
val fakeUser = LoggedInUser(java.util.UUID.randomUUID().toString(), "Jane Doe")
return Result.Success(fakeUser)
} catch (e: Throwable) {
return Result.Error(IOException("Error logging in", e))
}
}
fun logout() {
// TODO: revoke authentication
}
} | seven_navigation712/app/src/main/java/com/example/myapplication/data/LoginDataSource.kt | 2744021360 |
package com.example.myapplication.data.model
/**
* Data class that captures user information for logged in users retrieved from LoginRepository
*/
data class LoggedInUser(
val userId: String,
val displayName: String
) | seven_navigation712/app/src/main/java/com/example/myapplication/data/model/LoggedInUser.kt | 529611353 |
package com.example.myapplication.data
import com.example.myapplication.data.model.LoggedInUser
/**
* Class that requests authentication and user information from the remote data source and
* maintains an in-memory cache of login status and user credentials information.
*/
class LoginRepository(val dataSource: LoginDataSource) {
// in-memory cache of the loggedInUser object
var user: LoggedInUser? = null
private set
val isLoggedIn: Boolean
get() = user != null
init {
// If user credentials will be cached in local storage, it is recommended it be encrypted
// @see https://developer.android.com/training/articles/keystore
user = null
}
fun logout() {
user = null
dataSource.logout()
}
fun login(username: String, password: String): Result<LoggedInUser> {
// handle login
val result = dataSource.login(username, password)
if (result is Result.Success) {
setLoggedInUser(result.data)
}
return result
}
private fun setLoggedInUser(loggedInUser: LoggedInUser) {
this.user = loggedInUser
// If user credentials will be cached in local storage, it is recommended it be encrypted
// @see https://developer.android.com/training/articles/keystore
}
} | seven_navigation712/app/src/main/java/com/example/myapplication/data/LoginRepository.kt | 190813664 |
package com.wtf.wtmnotepad
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("com.wtf.wtmnotepad", appContext.packageName)
}
} | LuomahNotepad/app/src/androidTest/java/com/wtf/wtmnotepad/ExampleInstrumentedTest.kt | 318717871 |
package com.wtf.wtmnotepad
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)
}
} | LuomahNotepad/app/src/test/java/com/wtf/wtmnotepad/ExampleUnitTest.kt | 2160585717 |
package com.wtf.wtmnotepad.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) | LuomahNotepad/app/src/main/java/com/wtf/wtmnotepad/ui/theme/Color.kt | 3090701627 |
package com.wtf.wtmnotepad.ui.theme
import android.app.Activity
import android.os.Build
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.darkColorScheme
import androidx.compose.material3.dynamicDarkColorScheme
import androidx.compose.material3.dynamicLightColorScheme
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.runtime.SideEffect
import androidx.compose.ui.graphics.toArgb
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalView
import androidx.core.view.WindowCompat
private val DarkColorScheme = darkColorScheme(
primary = Purple80,
secondary = PurpleGrey80,
tertiary = Pink80
)
private val LightColorScheme = lightColorScheme(
primary = Purple40,
secondary = PurpleGrey40,
tertiary = Pink40
/* Other default colors to override
background = Color(0xFFFFFBFE),
surface = Color(0xFFFFFBFE),
onPrimary = Color.White,
onSecondary = Color.White,
onTertiary = Color.White,
onBackground = Color(0xFF1C1B1F),
onSurface = Color(0xFF1C1B1F),
*/
)
@Composable
fun WTMNotepadTheme(
darkTheme: Boolean = isSystemInDarkTheme(),
// Dynamic color is available on Android 12+
dynamicColor: Boolean = true,
content: @Composable () -> Unit
) {
val colorScheme = when {
dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
val context = LocalContext.current
if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
}
darkTheme -> DarkColorScheme
else -> LightColorScheme
}
val view = LocalView.current
if (!view.isInEditMode) {
SideEffect {
val window = (view.context as Activity).window
window.statusBarColor = colorScheme.primary.toArgb()
WindowCompat.getInsetsController(window, view).isAppearanceLightStatusBars = darkTheme
}
}
MaterialTheme(
colorScheme = colorScheme,
typography = Typography,
content = content
)
} | LuomahNotepad/app/src/main/java/com/wtf/wtmnotepad/ui/theme/Theme.kt | 3735612688 |
package com.wtf.wtmnotepad.ui.theme
import androidx.compose.material3.Typography
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.sp
// Set of Material typography styles to start with
val Typography = Typography(
bodyLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 16.sp,
lineHeight = 24.sp,
letterSpacing = 0.5.sp
)
/* Other default text styles to override
titleLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 22.sp,
lineHeight = 28.sp,
letterSpacing = 0.sp
),
labelSmall = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Medium,
fontSize = 11.sp,
lineHeight = 16.sp,
letterSpacing = 0.5.sp
)
*/
) | LuomahNotepad/app/src/main/java/com/wtf/wtmnotepad/ui/theme/Type.kt | 1277392595 |
package com.wtf.wtmnotepad
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.Image
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.MoreVert
import androidx.compose.material.icons.filled.Search
import androidx.compose.material3.Button
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Surface
import androidx.compose.material3.Switch
import androidx.compose.material3.Text
import androidx.compose.material3.TextField
import androidx.compose.material3.TopAppBar
import androidx.compose.material3.TopAppBarColors
import androidx.compose.material3.TopAppBarDefaults
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
import androidx.navigation.compose.rememberNavController
import com.wtf.wtmnotepad.ui.theme.WTMNotepadTheme
import com.wtf.wtmnotepad.screens.AddNoteScreen
import com.wtf.wtmnotepad.screens.NoteListScreen
import com.wtf.wtmnotepad.ui.theme.WTMNotepadTheme
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
WTMNotepadTheme {
// A surface container using the 'background' color from the theme
Surface(
modifier = Modifier.fillMaxSize(),
color = MaterialTheme.colorScheme.background
) {
AppNavigation()
}
}
}
}
}
@Composable
fun AppNavigation(){
val navController = rememberNavController()
NavHost(
navController = navController,
startDestination = "note-list"
){
composable("note-list"){
NoteListScreen(navController)
}
composable("add-note"){
AddNoteScreen()
}
}
} | LuomahNotepad/app/src/main/java/com/wtf/wtmnotepad/MainActivity.kt | 2762229660 |
package com.wtf.wtmnotepad.screens
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Add
import androidx.compose.material.icons.filled.MoreVert
import androidx.compose.material.icons.filled.Search
import androidx.compose.material3.Card
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.FloatingActionButton
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBar
import androidx.compose.material3.TopAppBarDefaults
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.navigation.NavController
import com.wtf.wtmnotepad.components.NoteItem
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun NoteListScreen(navController: NavController){
Scaffold(
topBar = {
TopAppBar(
title = { Text(text="WTM Note App") },
colors = TopAppBarDefaults.smallTopAppBarColors(
containerColor = MaterialTheme.colorScheme.primary,
titleContentColor = Color.White,
actionIconContentColor = Color.White
),
actions = {
IconButton(onClick = {}){
Icon(
imageVector = Icons.Default.Search,
contentDescription = "Search for note"
)
}
IconButton(onClick = {}){
Icon(
imageVector = Icons.Default.MoreVert,
contentDescription = "More Icon"
)
}
}
)
},
content = {paddingValues ->
Column(
modifier= Modifier
.padding(paddingValues)
.fillMaxSize()
) {
//Note Items WIll be here
NoteItem()
NoteItem()
NoteItem()
}
},
floatingActionButton = {
FloatingActionButton(onClick = { navController.navigate("add-note") }) {
Icon(
imageVector = Icons.Default.Add,
contentDescription = "Add New Note"
)
}
}
)
}
@Preview
@Composable
fun NoteListScreenPreview(){
Surface(
modifier = Modifier.fillMaxSize(),
color = MaterialTheme.colorScheme.background
) {
// NoteListScreen()
}
} | LuomahNotepad/app/src/main/java/com/wtf/wtmnotepad/screens/NoteListScreen.kt | 562405863 |
package com.wtf.wtmnotepad.screens
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Add
import androidx.compose.material.icons.filled.Clear
import androidx.compose.material.icons.filled.Edit
import androidx.compose.material.icons.filled.MoreVert
import androidx.compose.material.icons.filled.Search
import androidx.compose.material3.Button
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.material3.TextField
import androidx.compose.material3.TopAppBar
import androidx.compose.material3.TopAppBarDefaults
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.LineBreak
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import com.wtf.wtmnotepad.components.NoteItem
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun AddNoteScreen(){
var title by remember { mutableStateOf("")}
var newNote by remember { mutableStateOf("")}
Scaffold (
topBar = {
TopAppBar(
title = { Text(text = "Add a New Note") },
colors = TopAppBarDefaults.smallTopAppBarColors(
containerColor = MaterialTheme.colorScheme.primary,
titleContentColor = Color.White,
actionIconContentColor = Color.White
),
actions = {
IconButton(onClick = {}) {
Icon(imageVector = Icons.Default.Add ,contentDescription = "Add Note " )
}
IconButton(onClick = {}) {
Icon(imageVector = Icons.Default.Edit, contentDescription = "More Options" )
}
}
)
},
content = { paddingValues ->
Column(
modifier = androidx.compose.ui.Modifier
.padding(paddingValues),
horizontalAlignment = Alignment.CenterHorizontally
)
{
OutlinedTextField(
value = title,
onValueChange = {titleInput -> title= titleInput},
label = { Text(text = "Enter Note Title", fontWeight = FontWeight.Black)},
modifier = Modifier
.padding(horizontal = 15.dp)
.padding(top = 15.dp)
.fillMaxWidth()
.height(60.dp),
maxLines = 2, // Adjust as needed
)
Spacer(modifier = Modifier.height(5.dp))
OutlinedTextField(
value = newNote,
onValueChange = {newNoteInput -> newNote = newNoteInput},
label = { Text(text = "Enter content of the note")},
modifier = Modifier
.padding(horizontal = 15.dp)
.fillMaxWidth()
.height(100.dp),
maxLines = 9, // Adjust as needed
)
Button(
onClick = { },
modifier = Modifier
.padding(top = 16.dp)
) {
Text(text = "Add Note")
}
}
}
)
}
@Preview
@Composable
fun AddNoteScreenPreview(){
Surface(
modifier = Modifier.fillMaxSize(),
color = MaterialTheme.colorScheme.background
) {
// AddNoteScreen()
}
} | LuomahNotepad/app/src/main/java/com/wtf/wtmnotepad/screens/AddNoteScreen.kt | 2948045608 |
package com.wtf.wtmnotepad.components
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Card
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
@Composable
fun NoteItem(){
Card(
modifier = Modifier
.fillMaxWidth()
.padding(8.dp)
) {
Column(
modifier = Modifier
.fillMaxWidth()
.padding(8.dp)
){
Text(
text="Title of the note",
fontWeight = FontWeight.Black
)
Text(text="Study Group 3 Project completion")
}
}
} | LuomahNotepad/app/src/main/java/com/wtf/wtmnotepad/components/NoteItem.kt | 2356765165 |
import chessui.src.main.kotlin.Game
import kotlin.test.Test
import kotlin.test.assertEquals
internal class getAttacksTest {
@Test
fun testGetAttacksPawns() {
val game = Game("1nbqkbnr/p3pppp/8/4p3/3P4/8/P6P/K7 w k - 0 1")
// white pawns
assertEquals(setOf(41), game.getAttacks(48, game.board[48]))
assertEquals(setOf(26, 28), game.getAttacks(35, game.board[35]))
assertEquals(setOf(46), game.getAttacks(55, game.board[55]))
// black pawns
assertEquals(setOf(17), game.getAttacks(8, game.board[8]))
assertEquals(setOf(35, 37), game.getAttacks(28, game.board[28]))
assertEquals(setOf(22), game.getAttacks(15, game.board[15]))
}
@Test
fun testGetAttacksRooks() {
val game = Game("1nbqk1n1/p5pp/3p2r1/2PRp3/3P4/5r2/8/K2R4 w - - 0 1")
assertEquals(setOf(14, 19, 20, 21, 23, 30, 38, 46, 54, 62), game.getAttacks(22, game.board[22]))
assertEquals(setOf(19, 26, 28, 35), game.getAttacks(27, game.board[27]))
assertEquals(setOf(5, 13, 21, 29, 37, 40, 41, 42, 43, 44, 46, 47, 53, 61), game.getAttacks(45, game.board[45]))
assertEquals(setOf(35, 43, 51, 56, 57, 58, 60, 61, 62, 63), game.getAttacks(59, game.board[59]))
}
@Test
fun testGetAttacksKnights() {
val game = Game("2bqk2n/pn4pp/3p2r1/2PRp3/3Pn3/5r2/3K2N1/N2R4 w - - 0 1")
assertEquals(setOf(3, 19, 26, 24), game.getAttacks(9, game.board[9]))
assertEquals(setOf(13, 22), game.getAttacks(7, game.board[7]))
assertEquals(setOf(19, 21, 30, 46, 53, 51, 42, 26), game.getAttacks(36, game.board[36]))
assertEquals(setOf(37, 39, 44, 60), game.getAttacks(54, game.board[54]))
assertEquals(setOf(41, 50), game.getAttacks(56, game.board[56]))
}
@Test
fun testGetAttacksBishops() {
val game = Game("2bqk3/1n5p/3p2r1/3R4/3bn3/8/3K2B1/3R3b w - - 0 1")
assertEquals(setOf(8, 17, 26, 44, 53, 62, 7, 14, 21, 28, 42, 49, 56), game.getAttacks(35, game.board[35]))
assertEquals(setOf(36, 45, 63, 47, 61), game.getAttacks(54, game.board[54]))
assertEquals(setOf(54), game.getAttacks(63, game.board[63]))
}
@Test
fun testGetAttacksQueens() {
val game = Game("2b1k1q1/1n5p/3p2r1/8/3Qn3/1P6/6B1/5K1b w - - 0 1")
assertEquals(setOf(8, 17, 26, 44, 53, 62, 7, 14, 21, 28, 42, 49, 56, 19, 27, 32, 33, 34, 36, 43, 51, 59), game.getAttacks(35, game.board[35]))
assertEquals(setOf(4, 5, 7, 13, 14, 15, 20, 22, 27, 34, 41), game.getAttacks(6, game.board[6]))
}
@Test
fun testGetAttacksKings() {
val game = Game("2b3qk/1n5p/6r1/3p4/3K4/1P6/6B1/7b w - - 0 1")
assertEquals(setOf(26, 27, 28, 34, 36, 42, 43, 44), game.getAttacks(35, game.board[35]))
assertEquals(setOf(6, 14, 15), game.getAttacks(7, game.board[7]))
}
}
| chessUI/src/test/kotlin/getAttacksTest.kt | 1665432763 |
import chessui.src.main.kotlin.Game
import kotlin.test.Test
import kotlin.test.assertEquals
internal class getPinnedPiecesTest {
@Test
fun testGetPinnedPieces() {
val game = Game("3r3k/6bp/np6/2BpN3/r1PKr2q/2bQP3/8/b5b1 w - - 0 1")
assertEquals(setOf(34, 28, 44), game.getPinnedPieces(35))
}
}
| chessUI/src/test/kotlin/getPinnedPiecesTest.kt | 2973679808 |
// import chessui.src.main.kotlin.Game
// import kotlin.test.Test
// import kotlin.test.assertEquals
// internal class getBlockedPiecesTest {
// @Test
// fun testGetPiecesBlockedByPieceAt() {
// val game1 = Game("rnbqkbnr/p1pppppp/1pB5/8/4Q1B1/3b4/2P1R1P1/4K2R w Kkq - 0 1")
// assertEquals(setOf(18, 12, 15, 38, 43, 52, 54), game1.getPiecesBlockedByPieceAt(36))
// val game2 = Game("1nbq1bnr/p1kp1pp1/1p6/8/4Q3/8/8/3K4 w - - 0 1")
// assertEquals(setOf(), game2.getPiecesBlockedByPieceAt(36))
// }
// }
| chessUI/src/test/kotlin/getBlockedPiecesTest.kt | 1786565098 |
package chessui.src.main.kotlin
import org.apache.batik.anim.dom.SAXSVGDocumentFactory
import org.apache.batik.anim.dom.SVGDOMImplementation
import org.apache.batik.anim.dom.SVGOMDocument
import org.apache.batik.swing.JSVGCanvas
import org.apache.batik.util.XMLResourceDescriptor
import java.awt.Color
import java.awt.event.ComponentAdapter
import java.awt.event.ComponentEvent
import java.awt.event.MouseEvent
import java.awt.event.MouseListener
import java.io.IOException
import javax.swing.JComponent
import javax.swing.JFrame
class ChessUI(val game: Game) : JFrame() {
companion object {
private const val SQUARESPERSIDE = 8
private const val INITFRAMEWIDTH = 750
private const val FRAMETITLEBARHEIGHT = 28
private val DARKSQUARECOLOR = Color(174, 138, 105)
private val LIGHTSQUARECOLOR = Color(236, 218, 185)
private val HIGHLIGHTCOLORONE = Color(102, 111, 69)
private val HIGHLIGHTCOLORTWO = Color(134, 151, 110)
private val HIGHLIGHTCOLORTHREE = Color(206, 210, 120)
private val HIGHLIGHTCOLORFOUR = Color(168, 162, 76)
private val RED = Color(220, 20, 60)
private const val IMAGEDIR = "ChessPieces"
private val HIGHLIGHTCOLORONECIRCLE = object {}.javaClass.getResource("/$IMAGEDIR/circle1.svg").file.toString()
private val HIGHLIGHTCOLORTWOCIRCLE = object {}.javaClass.getResource("/$IMAGEDIR/circle2.svg").file.toString()
}
private var frameWidth = INITFRAMEWIDTH
private var frameHeight = INITFRAMEWIDTH + FRAMETITLEBARHEIGHT
private var squareSize = INITFRAMEWIDTH / SQUARESPERSIDE
private var currentBoardPos = game.board
private var previouslySelected: Pair<Int, Int>? = null
private var previouslySelectedPossibleMoves = setOf<Int>()
private var selectedSquareNum: Int? = null
private var selectedSquarePossibleMoves = setOf<Int>()
private val squares = Array<JSVGCanvas>(SQUARESPERSIDE * SQUARESPERSIDE) { JSVGCanvas() }
init {
// auto adjust to square on resize
this.addComponentListener(
object : ComponentAdapter() {
override fun componentResized(componentEvent: ComponentEvent) {
if (frameWidth != getContentPane().getWidth() || frameHeight != getContentPane().getHeight()) {
frameWidth = Math.min(getContentPane().getWidth(), getContentPane().getHeight())
frameHeight = frameWidth + FRAMETITLEBARHEIGHT
squareSize = frameWidth / SQUARESPERSIDE
setSize(frameWidth, frameHeight)
updateUI()
}
}
},
)
// click stuff
val getClicks = object : JComponent() {}
getClicks.setBounds(0, 0, squareSize * SQUARESPERSIDE, squareSize * SQUARESPERSIDE)
this.add(getClicks)
getClicks.addMouseListener(
object : MouseListener {
override fun mouseClicked(e: MouseEvent) {}
override fun mouseEntered(e: MouseEvent) {}
override fun mouseExited(e: MouseEvent) {}
override fun mousePressed(e: MouseEvent) {}
override fun mouseReleased(e: MouseEvent) {
val squareNum = e.getY() / squareSize * 8 + e.getX() / squareSize
if (squareNum > 63 || squareNum < 0) {
return
}
if (currentBoardPos == game.board && selectedSquareNum == squareNum) {
// purely so you can't spam click one square and cause the ui to glitch out
// the good solution would be to optimize updateUI
// but thats hard so I'll do it later
return
} else if (squareNum in selectedSquarePossibleMoves) {
game.movePiece(selectedSquareNum!!, squareNum)
previouslySelected = Pair(selectedSquareNum!!, squareNum)
previouslySelectedPossibleMoves = selectedSquarePossibleMoves
selectedSquareNum = null
selectedSquarePossibleMoves = setOf<Int>()
} else if (currentBoardPos[squareNum].color == game.currentPlayer) {
selectedSquareNum = squareNum
selectedSquarePossibleMoves = game.getPossibleMoves(squareNum)
} else {
selectedSquareNum = null
selectedSquarePossibleMoves = setOf<Int>()
}
updateUI()
}
},
)
updateUI()
// all the misc bits
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE)
setTitle("Chess")
pack()
setVisible(true)
setSize(frameWidth, frameHeight)
}
private fun fenToFileName(fenChar: Char): String {
return when (fenChar) {
'k' -> "bK.svg"
'q' -> "bQ.svg"
'r' -> "bR.svg"
'n' -> "bN.svg"
'b' -> "bB.svg"
'p' -> "bP.svg"
'K' -> "wK.svg"
'Q' -> "wQ.svg"
'R' -> "wR.svg"
'N' -> "wN.svg"
'B' -> "wB.svg"
'P' -> "wP.svg"
else -> throw IllegalArgumentException("Invalid FEN character: $fenChar")
}
}
private fun squareIsWhite(squareNum: Int): Boolean {
return squareNum % 2 - squareNum / 8 % 2 == 0
}
private fun highlightWithInverseCircle(squareNum: Int) {
// some truly awful awful code, but I really just wanted it to work
// I shall come back and clean it up eventually
val piece = currentBoardPos[squareNum]
if (piece.color == null) {
throw IllegalArgumentException("Implement Later")
}
if (!squareIsWhite(selectedSquareNum!!)) {
squares[squareNum].setBackground(DARKSQUARECOLOR)
} else {
squares[squareNum].setBackground(LIGHTSQUARECOLOR)
}
try {
val svgNS = SVGDOMImplementation.SVG_NAMESPACE_URI
val parser = XMLResourceDescriptor.getXMLParserClassName()
val f = SAXSVGDocumentFactory(parser)
val uri = object {}.javaClass.getResource("/$IMAGEDIR/${fenToFileName(piece.fenChar)}").file.toString()
val doc = f.createDocument(uri)
val svgRoot = doc.getDocumentElement()
for (i in listOf("M 0 0 L 0 10 A 25 25 0 0 1 10 0 z", "M 45 0 L 45 10 A 25 25 0 0 0 35 0 z", "M 45 45 L 45 35 A 25 25 0 0 1 35 45 z", "M 0 45 L 0 35 A 25 25 0 0 0 10 45 z")) {
val path = doc.createElementNS(svgNS, "path")
path.setAttributeNS(null, "d", i)
if (squareIsWhite(squareNum)) {
path.setAttributeNS(null, "fill", "rgb(134, 151, 110)")
} else {
path.setAttributeNS(null, "fill", "rgb(102, 111, 69)")
}
svgRoot.appendChild(path)
}
squares[squareNum].setSVGDocument(doc as SVGOMDocument)
} catch (ex: IOException) {
throw ex
}
}
private fun updateUI() {
currentBoardPos = game.board
// did it with absolute positioning cause I am a silly little guy
// who couldn't figure out how to make layout mangers do what he wanted
for (i in 0 until SQUARESPERSIDE) {
for (j in 0 until SQUARESPERSIDE) {
val currentSquareNum = j * 8 + i
val square = squares[currentSquareNum]
// add piece image to GUI
if (currentBoardPos[currentSquareNum].color != null) {
square.setURI(
object {}.javaClass.getResource(
"/$IMAGEDIR/${fenToFileName(currentBoardPos[currentSquareNum].fenChar)}",
).file.toString(),
)
} else {
square.setURI(null)
}
if (squareIsWhite(currentSquareNum)) square.setBackground(LIGHTSQUARECOLOR) else square.setBackground(DARKSQUARECOLOR)
square.setBounds(i * squareSize, j * squareSize, squareSize, squareSize)
this.add(square)
}
}
// highlights of previously selected piece
if (previouslySelected != null) {
if (!squareIsWhite(previouslySelected!!.first)) {
squares[previouslySelected!!.first].setBackground(HIGHLIGHTCOLORFOUR)
} else {
squares[previouslySelected!!.first].setBackground(HIGHLIGHTCOLORTHREE)
}
if (!squareIsWhite(previouslySelected!!.second)) {
squares[previouslySelected!!.second].setBackground(HIGHLIGHTCOLORFOUR)
} else {
squares[previouslySelected!!.second].setBackground(HIGHLIGHTCOLORTHREE)
}
}
// highlights of selected piece
if (selectedSquareNum != null) {
if (squareIsWhite(selectedSquareNum!!)) {
squares[selectedSquareNum!!].setBackground(HIGHLIGHTCOLORTWO)
} else {
squares[selectedSquareNum!!].setBackground(HIGHLIGHTCOLORONE)
}
val possibleMoves = selectedSquarePossibleMoves
for (move in possibleMoves) {
if (currentBoardPos[move].color == null) {
if (!squareIsWhite(move)) squares[move].setURI(HIGHLIGHTCOLORONECIRCLE) else squares[move].setURI(HIGHLIGHTCOLORTWOCIRCLE)
} else {
highlightWithInverseCircle(move)
}
}
}
if (game.inCheck(game.currentPlayer)) {
squares[game.board.getKingLocation(game.currentPlayer)].setBackground(RED)
}
// for (i in game.board.getPieceLocations()) {
// squares[i].setBackground(Color(173, 192, 222))
// }
// for (i in game.attacks[BLACK]!!) {
// squares[i].setBackground(Color(240, 146, 163))
// }
// for (i in game.getPinnedPieces(game.board.getKingLocation(WHITE))) {
// squares[i].setBackground(Color(115, 6, 25))
// }
}
}
| chessUI/src/main/kotlin/ChessUI.kt | 2487105174 |
package chessui.src.main.kotlin
class Piece(val fenChar: Char = ' ', val startingSquare: Int = -1) {
val isEmpty = fenChar == ' '
val color: Boolean? = if (isEmpty) null else fenChar.isUpperCase()
val isKing = fenChar.lowercase() == "k"
val isPawn = fenChar.lowercase() == "p"
val isFullBoardMover = fenChar.lowercase() in "qrb"
val moves: Set<Int>
init {
moves = when {
fenChar.lowercase() == "k" -> setOf(UP, DOWN, LEFT, RIGHT, UPLEFT, UPRIGHT, DOWNLEFT, DOWNRIGHT)
fenChar.lowercase() == "q" -> setOf(UP, DOWN, LEFT, RIGHT, UPLEFT, UPRIGHT, DOWNLEFT, DOWNRIGHT)
fenChar.lowercase() == "r" -> setOf(UP, DOWN, LEFT, RIGHT)
fenChar.lowercase() == "b" -> setOf(UPRIGHT, UPLEFT, DOWNRIGHT, DOWNLEFT)
fenChar.lowercase() == "n" -> setOf(-15, -17, 15, 17, 10, 6, -10, -6)
fenChar == 'p' -> setOf(DOWN)
fenChar == 'P' -> setOf(UP)
fenChar == ' ' -> setOf<Int>()
else -> throw IllegalArgumentException("Bad fenChar: $fenChar")
}
}
}
| chessUI/src/main/kotlin/Piece.kt | 261886419 |
package chessui.src.main.kotlin
fun main() {
// val game = Game("rnb1kbnr/pppppppp/8/KP5q/8/8/PPP1PPPP/RNBQ1BNR b kq - 0 1")
val game = Game()
val ui = ChessUI(game)
}
| chessUI/src/main/kotlin/Driver.kt | 389657212 |
package chessui.src.main.kotlin
import kotlin.math.abs
class Board(initialPos: String = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR") {
val emptyPiece = Piece()
private val board = Array<Piece>(TOTALSQUARES) { emptyPiece }
private val pieceLocations = mutableSetOf<Int>()
private val kingLocations = mutableMapOf(WHITE to -1, BLACK to -1)
val startingWhitePawnRow = 6
val startingBlackPawnRow = 1
init {
var i = 0
for (char in initialPos) {
if (char.isDigit()) {
i += char.digitToInt()
} else if (char != '/') {
board[i] = Piece(char, i)
if (board[i].isKing) {
kingLocations[board[i].color!!] = i
}
pieceLocations += i
i++
}
}
}
fun movePiece(from: Int, to: Int) {
if (!onBoard(from) || !onBoard(to)) {
throw IndexOutOfBoundsException("to: $to from: $from")
}
val piece = board[from]
pieceLocations -= from
pieceLocations += to
if (piece.isKing) {
kingLocations[piece.color!!] = to
}
board[from] = emptyPiece
board[to] = piece
}
fun setSquareEmpty(i: Int) {
if (!onBoard(i)) {
throw IndexOutOfBoundsException("i: $i")
}
pieceLocations -= i
board[i] = emptyPiece
}
operator fun get(i: Int?) = if (i != null) board[i] else emptyPiece
fun getCol(i: Int) = i % SQUARESPERSIDE
fun getRow(i: Int) = i / SQUARESPERSIDE
fun getPieceLocations(): Set<Int> = pieceLocations
fun getKingLocation(color: Boolean) = kingLocations[color]!!
fun getSquares(startingSquare: Int, direction: Int): List<Int> {
val squares = mutableListOf<Int>()
var i = startingSquare + direction
while (onBoard(i) && abs(getCol(i) - getCol(i - direction)) < 2 && board[i].isEmpty) {
squares += i
i += direction
}
if (onBoard(i) && abs(getCol(i) - getCol(i - direction)) < 2) {
squares += i
}
return squares
}
fun getPieceLocationsInDirection(startingSquare: Int, direction: Int): List<Int> {
val pieceLocations = mutableListOf<Int>()
var i = startingSquare + direction
while (onBoard(i) && abs(getCol(i) - getCol(i - direction)) < 2) {
if (!board[i].isEmpty) {
pieceLocations += i
}
i += direction
}
return pieceLocations
}
fun getSquaresBetween(i: Int, j: Int): List<Int> {
val smallerIndex = minOf(i, j)
val largerIndex = maxOf(i, j)
if (getRow(smallerIndex) == getRow(largerIndex)) {
return List<Int>(largerIndex - smallerIndex - 1) { smallerIndex + RIGHT + it * RIGHT }
}
if (getCol(smallerIndex) == getCol(largerIndex)) {
return List<Int>(getRow(largerIndex) - getRow(smallerIndex) - 1) { smallerIndex + DOWN + it * DOWN }
}
if (getRow(smallerIndex) + getCol(smallerIndex) == getRow(largerIndex) + getCol(largerIndex)) {
return List<Int>(getRow(largerIndex) - getRow(smallerIndex) - 1) { smallerIndex + DOWNLEFT + it * DOWNLEFT }
}
return List<Int>(getRow(largerIndex) - getRow(smallerIndex) - 1) { smallerIndex + DOWNRIGHT + it * DOWNRIGHT }
}
fun onBoard(i: Int) = i >= 0 && i < TOTALSQUARES
fun getFEN(): String {
var fen = ""
var sinceLastPiece = 0
for (i in board.indices) {
if (board[i].color != null) {
if (sinceLastPiece != 0) fen += sinceLastPiece.toString()
fen += board[i].fenChar
sinceLastPiece = 0
} else {
sinceLastPiece++
}
if ((i + 1) % 8 == 0) {
if (sinceLastPiece != 0) fen += sinceLastPiece.toString()
fen += "/"
sinceLastPiece = 0
}
}
return fen.substring(0, fen.length - 1)
}
}
| chessUI/src/main/kotlin/Board.kt | 3349799827 |
package chessui.src.main.kotlin
import kotlin.math.abs
class Game(initial: String = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1") {
var currentPlayer: Boolean = initial.split(" ")[1] == "w"
private set
private var castlingRights: String = initial.split(" ")[2]
private var enPassantTarget: Int = enPassantTargetStringToInt(initial.split(" ")[3])
private var fullMoves: Int = initial.split(" ")[4].toInt()
private var halfMoves: Int = initial.split(" ")[5].toInt()
val board = Board(initial.split(" ")[0])
val attacks = mapOf(WHITE to mutableListOf<Int>(), BLACK to mutableListOf<Int>())
val possibleMoves = mapOf(WHITE to mutableListOf<Int>(), BLACK to mutableListOf<Int>())
val movesThatBlockCheck = mutableMapOf(WHITE to List<Int>(TOTALSQUARES) { it }, BLACK to List<Int>(TOTALSQUARES) { it })
init {
for (pieceLocation in board.getPieceLocations()) {
attacks[board[pieceLocation].color!!]!! += getAttacks(pieceLocation, board[pieceLocation])
}
}
fun getPossibleMoves(square: Int): Set<Int> {
if (!board.onBoard(square)) {
throw IllegalArgumentException("$square is not a valid square")
}
val piece = board[square]
if (piece.isEmpty) {
throw IllegalArgumentException("No piece on square: $square")
}
val pieceColor = piece.color!!
if (square in getPinnedPieces(board.getKingLocation(pieceColor))) {
return setOf()
}
val moves = piece.moves.toMutableSet<Int>()
val possibleMoves = mutableSetOf<Int>()
val movesToRemove = mutableSetOf<Int>()
var i = 1
do {
for (move in moves) {
val newMove = square + move * i
if (!board.onBoard(newMove)) {
movesToRemove += move
} else if (abs(board.getCol(newMove) - board.getCol(newMove - move)) > 2) {
movesToRemove += move
} else if (board[newMove].color == piece.color) {
movesToRemove += move
} else if (!board[newMove].isEmpty) {
possibleMoves += newMove
movesToRemove += move
} else {
possibleMoves += newMove
}
}
moves -= movesToRemove
i++
} while (piece.isFullBoardMover && moves.size != 0)
// special pawn moves
if (piece.isPawn) {
// prevent pawn from capturing in front of itself
if (possibleMoves.size == 1 && !board[possibleMoves.elementAt(0)].isEmpty) {
possibleMoves.clear()
}
if (piece.color == WHITE) {
if (board.getRow(square) == board.startingWhitePawnRow && board[square + UP].isEmpty && board[square + UP + UP].isEmpty) {
possibleMoves += square + UP + UP
}
if ((board[square + UPRIGHT].color == BLACK || square + UPRIGHT == enPassantTarget) && board.getCol(square) != 7) {
possibleMoves += square + UPRIGHT
}
if ((board[square + UPLEFT].color == BLACK || square + UPLEFT == enPassantTarget) && board.getCol(square) != 0) {
possibleMoves += square + UPLEFT
}
} else {
if (board.getRow(square) == board.startingBlackPawnRow && board[square + DOWN].isEmpty && board[square + DOWN + DOWN].isEmpty) {
possibleMoves += square + DOWN + DOWN
}
if ((board[square + DOWNRIGHT].color == WHITE || square + DOWNRIGHT == enPassantTarget) && board.getCol(square) != 7) {
possibleMoves += square + DOWNRIGHT
}
if ((board[square + DOWNLEFT].color == WHITE || square + DOWNLEFT == enPassantTarget) && board.getCol(square) != 0) {
possibleMoves += square + DOWNLEFT
}
}
}
if (piece.isKing) {
if ('Q' in castlingRights && board[59].isEmpty && board[58].isEmpty && board[57].isEmpty && listOf(59, 58, 57).intersect(attacks[!pieceColor]!!) == setOf<Int>()) {
possibleMoves += 58
}
if ('K' in castlingRights && board[61].isEmpty && board[62].isEmpty && listOf(61, 62).intersect(attacks[!pieceColor]!!) == setOf<Int>()) {
possibleMoves += 62
}
if ('q' in castlingRights && board[1].isEmpty && board[2].isEmpty && board[3].isEmpty && listOf(1, 2, 3).intersect(attacks[!pieceColor]!!) == setOf<Int>()) {
possibleMoves += 2
}
if ('k' in castlingRights && board[5].isEmpty && board[5].isEmpty && listOf(5, 6).intersect(attacks[!pieceColor]!!) == setOf<Int>()) {
possibleMoves += 6
}
for (direction in DIRECTIONS) {
val pieceLocations = board.getPieceLocationsInDirection(board.getKingLocation(pieceColor), direction)
val nearestPiece = board[pieceLocations.getOrNull(0) ?: continue]
if (nearestPiece.isFullBoardMover && -1 * direction in nearestPiece.moves && nearestPiece.color == !pieceColor) {
possibleMoves -= square + -1 * direction
}
}
return possibleMoves - attacks[!pieceColor]!!
}
return possibleMoves.intersect(movesThatBlockCheck[pieceColor]!!)
}
fun getAttacks(square: Int, piece: Piece): Set<Int> {
if (!board.onBoard(square)) {
throw IllegalArgumentException("$square is not a valid square")
}
val moves = piece.moves.toMutableSet<Int>()
val movesToRemove = mutableSetOf<Int>()
val attacks = mutableSetOf<Int>()
if (piece.isPawn) {
if (piece.color == WHITE) {
if (board.getCol(square) != 7) {
attacks += square + UPRIGHT
}
if (board.getCol(square) != 0) {
attacks += square + UPLEFT
}
} else {
if (board.getCol(square) != 7) {
attacks += square + DOWNRIGHT
}
if (board.getCol(square) != 0) {
attacks += square + DOWNLEFT
}
}
return attacks
}
var i = 1
do {
for (move in moves) {
val newMove = square + move * i
if (!board.onBoard(newMove)) {
movesToRemove += move
} else if (abs(board.getCol(newMove) - board.getCol(newMove - move)) > 2) {
movesToRemove += move
} else if (board[newMove].color == piece.color) {
attacks += newMove
movesToRemove += move
} else if (!board[newMove].isEmpty) {
attacks += newMove
movesToRemove += move
} else {
attacks += newMove
}
}
moves -= movesToRemove
i++
} while (piece.isFullBoardMover && moves.size != 0)
return attacks
}
fun movePiece(
from: Int,
to: Int,
) {
// check for validity
val piece = board[from]
if (to == enPassantTarget) {
if (piece.color == WHITE) {
board.setSquareEmpty(enPassantTarget + 8)
} else {
board.setSquareEmpty(enPassantTarget - 8)
}
}
if (piece.isPawn && to == from + piece.moves.elementAt(0) * 2) {
enPassantTarget = from + piece.moves.elementAt(0)
} else {
enPassantTarget = -1
}
if (piece.isKing) {
var rookFrom = 0
var rookTo = 0
if (from - to == -2) {
rookFrom = from + 3
rookTo = from + 1
} else if (from - to == 2) {
rookFrom = from - 4
rookTo = from - 1
}
movePiece(rookFrom, rookTo)
currentPlayer = !currentPlayer
}
val oldAttacks = getAttacks(from, piece)
val newAttacks = getAttacks(to, piece)
oldAttacks.forEach { attacks[currentPlayer]!! -= it }
attacks[currentPlayer]!! += newAttacks
if (!board[to].isEmpty) {
getAttacks(to, board[to]).forEach { attacks[!currentPlayer]!! -= it }
}
if (board.getKingLocation(!currentPlayer) in newAttacks) {
if (piece.fenChar.lowercase() == "n") {
movesThatBlockCheck[!currentPlayer] = listOf(to)
} else {
movesThatBlockCheck[!currentPlayer] = movesThatBlockCheck[!currentPlayer]!!.intersect(board.getSquaresBetween(board.getKingLocation(!currentPlayer), to)).toList()
}
}
board.movePiece(from, to)
for (direction in DIRECTIONS) {
val pieceLocationsTo = board.getPieceLocationsInDirection(to, direction)
val nearestPieceTo = board[pieceLocationsTo.getOrNull(0) ?: continue]
if (nearestPieceTo.isFullBoardMover && -1 * direction in nearestPieceTo.moves) {
board.getSquares(to, -1 * direction).forEach { attacks[nearestPieceTo.color!!]!! -= it }
}
}
for (direction in DIRECTIONS) {
val pieceLocationsFrom = board.getPieceLocationsInDirection(from, direction)
val nearestPieceFrom = board[pieceLocationsFrom.getOrNull(0) ?: continue]
if (nearestPieceFrom.isFullBoardMover && -1 * direction in nearestPieceFrom.moves) {
val attacksToAdd = board.getSquares(from, -1 * direction)
attacks[nearestPieceFrom.color!!]!! += attacksToAdd
if (nearestPieceFrom.color == currentPlayer && board.getKingLocation(!currentPlayer) in attacksToAdd) {
movesThatBlockCheck[!currentPlayer] = movesThatBlockCheck[!currentPlayer]!!.intersect(board.getSquaresBetween(board.getKingLocation(!currentPlayer), pieceLocationsFrom[0])).toList()
}
}
}
movesThatBlockCheck[currentPlayer] = List<Int>(TOTALSQUARES) { it }
currentPlayer = !currentPlayer
}
fun getPinnedPieces(squareNum: Int): Set<Int> {
val piece = board[squareNum]
val pieceColor = piece.color!!
val pinnedPieces = mutableSetOf<Int>()
for (direction in DIRECTIONS) {
val pieceLocations = board.getPieceLocationsInDirection(squareNum, direction)
if (pieceLocations.size >= 2 &&
board[pieceLocations[0]].color == pieceColor &&
board[pieceLocations[1]].color == !pieceColor &&
board[pieceLocations[1]].isFullBoardMover
) {
pinnedPieces += pieceLocations[0]
}
}
return pinnedPieces
}
fun inCheck(color: Boolean): Boolean {
if (color == WHITE) {
return board.getKingLocation(WHITE) in attacks[BLACK]!!
} else {
return board.getKingLocation(BLACK) in attacks[WHITE]!!
}
}
fun hasMoves(color: Boolean): Boolean {
return false
}
fun endOfGame(): Boolean {
return hasMoves(WHITE) && hasMoves(BLACK)
}
fun winner(): Boolean? {
// true for white
// false for black
// null for draw
return if (inCheck(WHITE)) {
BLACK
} else if (inCheck(BLACK)) {
WHITE
} else {
null
}
}
fun enPassantTargetStringToInt(target: String): Int {
val alphabet = "abcdefgh"
return if (target == "-") {
-1
} else {
alphabet.indexOf(target[0]) + abs(target[1].digitToInt() - 8)
}
}
fun enPassantTargetIntToString(target: Int): String {
val alphabet = "abcdefgh"
return if (target == -1) {
"-"
} else {
alphabet[target % 8] + (abs((target / 8) - 8)).toString()
}
}
override fun toString(): String {
return "${board.getFEN()} ${if (currentPlayer) 'w' else 'b'} $castlingRights ${enPassantTargetIntToString(
enPassantTarget,
)} $fullMoves $halfMoves"
}
}
| chessUI/src/main/kotlin/Game.kt | 1087662483 |
package chessui.src.main.kotlin
import javax.swing.JFrame
class PrescreenUI() : JFrame()
| chessUI/src/main/kotlin/PrescreenUI.kt | 4197910383 |
package chessui.src.main.kotlin
const val SQUARESPERSIDE = 8
const val TOTALSQUARES = SQUARESPERSIDE * SQUARESPERSIDE
const val UP = -1 * SQUARESPERSIDE
const val DOWN = SQUARESPERSIDE
const val LEFT = -1
const val RIGHT = 1
const val UPLEFT = -1 * (SQUARESPERSIDE + 1)
const val UPRIGHT = -1 * (SQUARESPERSIDE - 1)
const val DOWNRIGHT = SQUARESPERSIDE + 1
const val DOWNLEFT = SQUARESPERSIDE - 1
val DIRECTIONS = listOf(UP, UPRIGHT, RIGHT, DOWNRIGHT, DOWN, DOWNLEFT, LEFT, UPLEFT)
const val WHITE = true
const val BLACK = false
| chessUI/src/main/kotlin/Constants.kt | 2194666950 |
class Estudiante(nombre: String, edad: Int, val carrera: String) : Persona(nombre, edad ) {
override fun toString(): String {
return super.toString().dropLast(2).replace("Persona", "Estudiante") + ", carrera = $carrera )"
}
override fun actividad(): String {
return "$nombre está estudiando para un examen"
}
}
| Ejercicio_3_Persona-Estudiante/Ejer_3_Persona_Estudiante/src/Estudiante.kt | 3501891934 |
fun main() {
val yo = Persona("lautaro", 18)
println(yo)
yo.cumple()
println(yo)
println(yo.actividad())
val es = Estudiante("Pablo", 21, "Medicina" )
println(es)
es.cumple()
println(es)
println(es.actividad())
} | Ejercicio_3_Persona-Estudiante/Ejer_3_Persona_Estudiante/src/Main.kt | 2346633799 |
open class Persona(val nombre: String, edad: Int) {
var edad: Int = edad
set(value) {
require(value >= 0) { "La edad no puede ser negativa" }
field = value
}
init {
require(nombre.isNotBlank()) { "El nombre no puede estar vacío" }
this.edad = edad
}
fun cumple() {
edad++
println("$nombre tiene un año más")
}
open fun actividad(): String {
return "$nombre está realizando una actividad"
}
override fun toString(): String {
return "Persona (nombre = $nombre, edad = $edad)"
}
}
| Ejercicio_3_Persona-Estudiante/Ejer_3_Persona_Estudiante/src/Persona.kt | 417544482 |
package com.spudit
import com.facebook.react.ReactActivity
import com.facebook.react.ReactActivityDelegate
import com.facebook.react.defaults.DefaultNewArchitectureEntryPoint.fabricEnabled
import com.facebook.react.defaults.DefaultReactActivityDelegate
class MainActivity : ReactActivity() {
/**
* Returns the name of the main component registered from JavaScript. This is used to schedule
* rendering of the component.
*/
override fun getMainComponentName(): String = "spudit"
/**
* Returns the instance of the [ReactActivityDelegate]. We use [DefaultReactActivityDelegate]
* which allows you to enable New Architecture with a single boolean flags [fabricEnabled]
*/
override fun createReactActivityDelegate(): ReactActivityDelegate =
DefaultReactActivityDelegate(this, mainComponentName, fabricEnabled)
}
| spudit/android/app/src/main/java/com/spudit/MainActivity.kt | 2882516049 |
package com.spudit
import android.app.Application
import com.facebook.react.PackageList
import com.facebook.react.ReactApplication
import com.facebook.react.ReactHost
import com.facebook.react.ReactNativeHost
import com.facebook.react.ReactPackage
import com.facebook.react.defaults.DefaultNewArchitectureEntryPoint.load
import com.facebook.react.defaults.DefaultReactHost.getDefaultReactHost
import com.facebook.react.defaults.DefaultReactNativeHost
import com.facebook.react.flipper.ReactNativeFlipper
import com.facebook.soloader.SoLoader
class MainApplication : Application(), ReactApplication {
override val reactNativeHost: ReactNativeHost =
object : DefaultReactNativeHost(this) {
override fun getPackages(): List<ReactPackage> {
// Packages that cannot be autolinked yet can be added manually here, for example:
// packages.add(new MyReactNativePackage());
return PackageList(this).packages
}
override fun getJSMainModuleName(): String = "index"
override fun getUseDeveloperSupport(): Boolean = BuildConfig.DEBUG
override val isNewArchEnabled: Boolean = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
override val isHermesEnabled: Boolean = BuildConfig.IS_HERMES_ENABLED
}
override val reactHost: ReactHost
get() = getDefaultReactHost(this.applicationContext, reactNativeHost)
override fun onCreate() {
super.onCreate()
SoLoader.init(this, false)
if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
// If you opted-in for the New Architecture, we load the native entry point for this app.
load()
}
ReactNativeFlipper.initializeFlipper(this, reactNativeHost.reactInstanceManager)
}
}
| spudit/android/app/src/main/java/com/spudit/MainApplication.kt | 2079408270 |
package com.example.weatherapp
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("com.example.weatherapp", appContext.packageName)
}
} | weatherApp/app/src/androidTest/java/com/example/weatherapp/ExampleInstrumentedTest.kt | 2646554615 |
package com.example.weatherapp
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)
}
} | weatherApp/app/src/test/java/com/example/weatherapp/ExampleUnitTest.kt | 1074146430 |
package com.example.weatherapp.ui
import WeatherListItem
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material3.Text
import androidx.compose.material3.TextField
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.input.TextFieldValue
import androidx.compose.ui.tooling.preview.Preview
import androidx.lifecycle.viewmodel.compose.viewModel
import com.example.weatherapp.WeatherViewModel
import com.example.weatherapp.ui.theme.WeatherAppTheme
@Composable
fun WeatherScreen(viewModel: WeatherViewModel = viewModel()) {
var query by remember { mutableStateOf(TextFieldValue()) }
Column(
modifier = Modifier.fillMaxWidth(),
horizontalAlignment = Alignment.CenterHorizontally
) {
TextField(
value = query,
onValueChange = {
query = it
if (query.text.length > 2) {
viewModel.fetchWeatherData(it.text)
}
},
label = { Text("Enter city or zip code") },
modifier = Modifier.fillMaxWidth()
)
val weatherData by viewModel.uiState.collectAsState()
weatherData?.let {
LazyColumn {
items(listOf(it)) {
WeatherListItem(response = it)
}
}
} ?: run {
Text(text = "Please enter a correct city name")
}
}
}
@Preview(showBackground = true)
@Composable
fun DefaultPreview() {
WeatherAppTheme {
WeatherScreen()
}
} | weatherApp/app/src/main/java/com/example/weatherapp/ui/WeatherScreen.kt | 1001639777 |
package com.example.weatherapp.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) | weatherApp/app/src/main/java/com/example/weatherapp/ui/theme/Color.kt | 1126046537 |
package com.example.weatherapp.ui.theme
import android.app.Activity
import android.os.Build
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.darkColorScheme
import androidx.compose.material3.dynamicDarkColorScheme
import androidx.compose.material3.dynamicLightColorScheme
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.runtime.SideEffect
import androidx.compose.ui.graphics.toArgb
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalView
import androidx.core.view.WindowCompat
private val DarkColorScheme = darkColorScheme(
primary = Purple80,
secondary = PurpleGrey80,
tertiary = Pink80
)
private val LightColorScheme = lightColorScheme(
primary = Purple40,
secondary = PurpleGrey40,
tertiary = Pink40
/* Other default colors to override
background = Color(0xFFFFFBFE),
surface = Color(0xFFFFFBFE),
onPrimary = Color.White,
onSecondary = Color.White,
onTertiary = Color.White,
onBackground = Color(0xFF1C1B1F),
onSurface = Color(0xFF1C1B1F),
*/
)
@Composable
fun WeatherAppTheme(
darkTheme: Boolean = isSystemInDarkTheme(),
// Dynamic color is available on Android 12+
dynamicColor: Boolean = true,
content: @Composable () -> Unit
) {
val colorScheme = when {
dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
val context = LocalContext.current
if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
}
darkTheme -> DarkColorScheme
else -> LightColorScheme
}
val view = LocalView.current
if (!view.isInEditMode) {
SideEffect {
val window = (view.context as Activity).window
window.statusBarColor = colorScheme.primary.toArgb()
WindowCompat.getInsetsController(window, view).isAppearanceLightStatusBars = darkTheme
}
}
MaterialTheme(
colorScheme = colorScheme,
typography = Typography,
content = content
)
} | weatherApp/app/src/main/java/com/example/weatherapp/ui/theme/Theme.kt | 2458874510 |
package com.example.weatherapp.ui.theme
import androidx.compose.material3.Typography
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.sp
// Set of Material typography styles to start with
val Typography = Typography(
bodyLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 16.sp,
lineHeight = 24.sp,
letterSpacing = 0.5.sp
)
/* Other default text styles to override
titleLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 22.sp,
lineHeight = 28.sp,
letterSpacing = 0.sp
),
labelSmall = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Medium,
fontSize = 11.sp,
lineHeight = 16.sp,
letterSpacing = 0.5.sp
)
*/
) | weatherApp/app/src/main/java/com/example/weatherapp/ui/theme/Type.kt | 3796718707 |
import androidx.compose.foundation.Image
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.size
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import coil.compose.rememberImagePainter
import coil.size.Scale
@Composable
fun WeatherIcon(iconId: String) {
val url = "https://openweathermap.org/img/wn/$iconId.png"
val painter = rememberImagePainter(
data = url,
builder = {
scale(Scale.FIT) // Scale the image to fit into the layout
}
)
Box(modifier = Modifier.size(50.dp)) {
Image(
painter = painter,
contentDescription = null, // Content description is not needed for weather icons
modifier = Modifier.fillMaxSize()
)
}
}
| weatherApp/app/src/main/java/com/example/weatherapp/ui/WeatherIcon.kt | 1569105368 |
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import com.example.weatherapp.WeatherResponse
import com.example.weatherapp.data.Weather
@Composable
fun WeatherListItem(response: WeatherResponse) {
// TODO Made list item to support multiple responses from API in case of duplicate cities, for now only supports 1
Row(
modifier = Modifier
.fillMaxWidth()
.background(Color.Black)
.padding(16.dp),
verticalAlignment = Alignment.CenterVertically
) {
WeatherIcon(iconId = response.weather.first().icon)
Spacer(modifier = Modifier.width(16.dp))
Column {
Text(text = response.name, color = Color.White)
Text(text = response.weather.first().main +" - " + response.weather.first().description, color = Color.White)
Text(text = "Current temp = " + kelvinToFahrenheit(response.main.temp) + "F", color = Color.White)
Text(text = "Temp range = " + kelvinToFahrenheit(response.main.temp_min) + "F" + " - " + kelvinToFahrenheit(response.main.temp_max) + "F", color = Color.White)
Text(text = "Humidity = " + response.main.humidity +"%", color = Color.White)
}
}
}
fun kelvinToFahrenheit(kelvin: Float): Int {
return ((kelvin - 273.15) * 9 / 5 + 32).toInt()
}
| weatherApp/app/src/main/java/com/example/weatherapp/ui/WeatherListItem.kt | 901445970 |
package com.example.weatherapp
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.viewModels
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.tooling.preview.Preview
import com.example.weatherapp.ui.WeatherScreen
import com.example.weatherapp.ui.theme.WeatherAppTheme
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
WeatherAppTheme {
// A surface container using the 'background' color from the theme
Surface(
modifier = Modifier.fillMaxSize(),
color = MaterialTheme.colorScheme.background
) {
WeatherScreen()
}
}
}
}
} | weatherApp/app/src/main/java/com/example/weatherapp/MainActivity.kt | 2905094424 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.