diff --git a/demo-app/src/main/assets/uikit/stories_sample.json b/demo-app/src/main/assets/uikit/stories_sample.json new file mode 100644 index 00000000..6d9eec01 --- /dev/null +++ b/demo-app/src/main/assets/uikit/stories_sample.json @@ -0,0 +1,499 @@ +{ + "id": "sample", + "settings": {}, + "stories": [ + { + "id": 901, + "name": "Скидки недели на обувь и часы", + "avatar": "file:///android_asset/uikit/sneakers.jpg", + "pinned": true, + "viewed": false, + "start_position": 0, + "slides": [ + { + "id": "901_0", + "type": "", + "duration": 6, + "background": "", + "elements": [ + { + "type": "product", + "title": " ", + "item": { + "id": "1", + "brand": "Pegasus", + "name": "Кроссовки беговые Pegasus 41, сетчатый верх", + "image_url": "file:///android_asset/uikit/sneakers.jpg", + "picture": "file:///android_asset/uikit/sneakers.jpg", + "price": 9990, + "price_formatted": "9 990 ₽", + "url": "https://example.com/p/1", + "oldprice": 12990, + "oldprice_formatted": "12 990 ₽", + "discount": 23, + "discount_percent": 23 + } + }, + { + "type": "button", + "title": "Купить", + "link": "https://example.com", + "link_android": "https://example.com", + "background": "#3b82f6", + "color": "#ffffff" + } + ] + }, + { + "id": "901_1", + "type": "", + "duration": 6, + "background": "", + "elements": [ + { + "type": "product", + "title": " ", + "item": { + "id": "2", + "brand": "Chrono", + "name": "Часы наручные Chrono Classic, сталь, 40 мм", + "image_url": "file:///android_asset/uikit/watch.jpg", + "picture": "file:///android_asset/uikit/watch.jpg", + "price": 24990, + "price_formatted": "24 990 ₽", + "url": "https://example.com/p/2", + "promocode": "YAGODA-MALINA", + "price_with_promocode_formatted": "19 990 ₽" + } + }, + { + "type": "button", + "title": "Купить", + "link": "https://example.com", + "link_android": "https://example.com", + "background": "#3b82f6", + "color": "#ffffff" + } + ] + }, + { + "id": "901_2", + "type": "", + "duration": 6, + "background": "", + "elements": [ + { + "type": "text_block", + "text_input": "Ваш промокод SOUND10", + "promocode": "SOUND10", + "font_size": 20, + "y_offset": 10 + }, + { + "type": "product", + "title": " ", + "item": { + "id": "3", + "brand": "Sonic", + "name": "Наушники беспроводные Sonic Pro с шумоподавлением", + "image_url": "file:///android_asset/uikit/headphones.jpg", + "picture": "file:///android_asset/uikit/headphones.jpg", + "price": 7490, + "price_formatted": "7 490 ₽", + "url": "https://example.com/p/3" + } + }, + { + "type": "button", + "title": "Купить", + "link": "https://example.com", + "link_android": "https://example.com", + "background": "#3b82f6", + "color": "#ffffff" + } + ] + } + ] + }, + { + "id": 907, + "name": "GIF", + "avatar": "file:///android_asset/uikit/story_clock.gif", + "pinned": false, + "viewed": false, + "start_position": 0, + "slides": [ + { + "id": "907_0", + "type": "image", + "duration": 5, + "background": "file:///android_asset/uikit/story_clock.gif", + "background_color": "#1B2A41", + "elements": [] + } + ] + }, + { + "id": 905, + "name": "Видео и товары", + "avatar": "file:///android_asset/uikit/headphones.jpg", + "pinned": false, + "viewed": false, + "start_position": 0, + "slides": [ + { + "id": "905_0", + "type": "video", + "duration": 0, + "background": "https://cdn.stories.rees46.ru/9f3065c8-82bc-4f4f-8fca-6b9ee4d4ae57.mp4", + "preview": "https://cdn.stories.rees46.ru/69c1044a-0ba5-42a4-b8b8-2fae2dff9125.jpg", + "background_color": "#101820", + "elements": [ + { + "type": "product", + "title": "Ваш промокод", + "item": { + "id": "3", + "brand": "Sonic", + "name": "Наушники беспроводные Sonic Pro с шумоподавлением", + "image_url": "file:///android_asset/uikit/headphones.jpg", + "price": 7490, + "price_formatted": "7 490 ₽", + "url": "https://example.com/p/3", + "promocode": "SOUND15", + "price_with_promocode_formatted": "6 367 ₽" + } + }, + { + "type": "button", + "title": "Купить", + "link_android": "https://example.com/buy/3" + }, + { + "type": "button", + "title": "Все наушники", + "link": "https://example.com/c/headphones" + }, + { + "type": "products", + "labels": { + "show_carousel": "С этим покупают", + "hide_carousel": "Скрыть" + }, + "products": [ + { + "id": "4", + "brand": "Trail", + "name": "Рюкзак городской Trail 20 л", + "image_url": "file:///android_asset/uikit/backpack.jpg", + "picture": "file:///android_asset/uikit/backpack.jpg", + "price": 4990, + "price_formatted": "4 990 ₽", + "url": "https://example.com/p/4", + "oldprice": 5990, + "oldprice_formatted": "5 990 ₽", + "discount": 17 + }, + { + "id": "5", + "brand": "Sunny", + "name": "Очки солнцезащитные Sunny", + "image_url": "file:///android_asset/uikit/sunglasses.jpg", + "picture": "file:///android_asset/uikit/sunglasses.jpg", + "price": 2990, + "price_formatted": "2 990 ₽", + "url": "https://example.com/p/5" + }, + { + "id": "6", + "brand": "Aqua", + "name": "Бутылка для воды Aqua 0,75 л", + "image_url": "file:///android_asset/uikit/bottle.jpg", + "picture": "file:///android_asset/uikit/bottle.jpg", + "price": 990, + "price_formatted": "990 ₽", + "url": "https://example.com/p/6", + "oldprice": 1290, + "oldprice_formatted": "1 290 ₽", + "discount": 23 + } + ] + } + ] + } + ] + }, + { + "id": 906, + "name": "Фото целиком и ошибка", + "avatar": "file:///android_asset/uikit/loyalty_stripe.jpg", + "pinned": false, + "viewed": false, + "start_position": 0, + "slides": [ + { + "id": "906_0", + "type": "image", + "duration": 5, + "background": "file:///android_asset/uikit/loyalty_stripe.jpg", + "background_color": "#1B2A41", + "elements": [] + }, + { + "id": "906_1", + "type": "image", + "duration": 5, + "background": "https://invalid.example/missing.jpg", + "background_color": "#000000", + "elements": [ + { + "type": "text_block", + "text_input": "Картинка не загрузится — нажмите «Повторить»", + "font_size": 20, + "y_offset": 10, + "text_align": "center", + "text_color": "#FFFFFF", + "text_background_color": "#000000", + "text_background_color_opacity": "0%", + "bold": false, + "italic": false, + "font_type": "" + } + ] + } + ] + }, + { + "id": 902, + "name": "Образ на выходные", + "avatar": "file:///android_asset/uikit/jacket.jpg", + "pinned": false, + "viewed": false, + "start_position": 0, + "slides": [ + { + "id": "902_0", + "type": "image", + "duration": 8, + "background": "file:///android_asset/uikit/jacket.jpg", + "background_color": "#000000", + "elements": [ + { + "type": "button", + "title": "Смотреть образ", + "link": "https://example.com", + "link_android": "https://example.com", + "background": "#3b82f6", + "color": "#ffffff" + }, + { + "type": "products", + "labels": { + "show_carousel": "Используемые товары", + "hide_carousel": "Скрыть товары" + }, + "products": [ + { + "id": "4", + "brand": "Trail", + "name": "Рюкзак городской Trail 20 л", + "image_url": "file:///android_asset/uikit/backpack.jpg", + "picture": "file:///android_asset/uikit/backpack.jpg", + "price": 4990, + "price_formatted": "4 990 ₽", + "url": "https://example.com/p/4", + "oldprice": 5990, + "oldprice_formatted": "5 990 ₽", + "discount": 17 + }, + { + "id": "5", + "brand": "Sunny", + "name": "Очки солнцезащитные Sunny", + "image_url": "file:///android_asset/uikit/sunglasses.jpg", + "picture": "file:///android_asset/uikit/sunglasses.jpg", + "price": 2990, + "price_formatted": "2 990 ₽", + "url": "https://example.com/p/5" + }, + { + "id": "6", + "brand": "Aqua", + "name": "Бутылка для воды Aqua 0,75 л", + "image_url": "file:///android_asset/uikit/bottle.jpg", + "picture": "file:///android_asset/uikit/bottle.jpg", + "price": 990, + "price_formatted": "990 ₽", + "url": "https://example.com/p/6", + "oldprice": 1290, + "oldprice_formatted": "1 290 ₽", + "discount": 23 + } + ] + } + ] + }, + { + "id": "902_1", + "type": "image", + "duration": 6, + "background": "file:///android_asset/uikit/backpack.jpg", + "background_color": "#000000", + "elements": [] + } + ] + }, + { + "id": 903, + "name": "Текст", + "avatar": "file:///android_asset/uikit/bottle.jpg", + "pinned": false, + "viewed": false, + "start_position": 1, + "slides": [ + { + "id": "903_0", + "type": "image", + "duration": 6, + "background": "file:///android_asset/uikit/sunglasses.jpg", + "background_color": "#000000", + "elements": [ + { + "type": "text_block", + "text_input": "Первый слайд уже просмотрен — лента продолжила со второго", + "font_size": 20, + "y_offset": 40, + "text_align": "left", + "text_color": "#FFFFFF", + "text_background_color": "#0087E8", + "text_background_color_opacity": "100%", + "text_line_spacing": 1.0, + "bold": false, + "italic": false, + "font_type": "" + }, + { + "type": "text_block", + "text_input": "Промокод SALE10 — нажмите, чтобы скопировать", + "promocode": "SALE10", + "font_size": 20, + "y_offset": 70, + "text_align": "center", + "text_color": "#FFFFFF", + "text_background_color": "#1BAA1B", + "text_background_color_opacity": "100%", + "bold": true, + "italic": false, + "font_type": "" + } + ] + }, + { + "id": "903_1", + "type": "image", + "duration": 8, + "background": "file:///android_asset/uikit/bottle.jpg", + "background_color": "#000000", + "elements": [ + { + "type": "text_block", + "text_input": "Open eat dear winding belonging.", + "font_size": 48, + "y_offset": 0, + "text_align": "left", + "text_color": "#FFFFFF", + "text_background_color": "#1BAA1B", + "text_background_color_opacity": "100%", + "text_line_spacing": 1.0, + "bold": false, + "italic": false, + "font_type": "" + }, + { + "type": "text_block", + "text_input": "Open eat dear winding belonging though differed stand left.", + "font_size": 30, + "y_offset": 27, + "text_align": "left", + "text_color": "#FFFFFF", + "text_background_color": "#F37A17", + "text_background_color_opacity": "100%", + "text_line_spacing": 1.0, + "bold": false, + "italic": false, + "font_type": "" + }, + { + "type": "text_block", + "text_input": "Open eat dear winding belonging though differed stand left.", + "font_size": 20, + "y_offset": 45, + "text_align": "left", + "text_color": "#FFFFFF", + "text_background_color": "#0087E8", + "text_background_color_opacity": "100%", + "text_line_spacing": 1.0, + "bold": false, + "italic": false, + "font_type": "" + }, + { + "type": "text_block", + "text_input": "Open eat dear winding belonging.", + "font_size": 48, + "y_offset": 56, + "text_align": "center", + "text_color": "#FFFFFF", + "text_background_color": "#0087E8", + "text_background_color_opacity": "0%", + "text_line_spacing": 1.0, + "bold": false, + "italic": false, + "font_type": "" + }, + { + "type": "text_block", + "text_input": "Open eat dear winding belonging though differed stand left.", + "font_size": 20, + "y_offset": 80, + "text_align": "right", + "text_color": "#FFFFFF", + "text_background_color": "#0087E8", + "text_background_color_opacity": "0%", + "text_line_spacing": 1.0, + "bold": false, + "italic": false, + "font_type": "" + }, + { + "type": "button", + "title": "Подробнее", + "link": "https://example.com", + "link_android": "https://example.com", + "background": "#3b82f6", + "color": "#ffffff" + } + ] + } + ] + }, + { + "id": 904, + "name": "Просмотрено", + "avatar": "file:///android_asset/uikit/watch.jpg", + "pinned": false, + "viewed": true, + "start_position": 0, + "slides": [ + { + "id": "904_0", + "type": "image", + "duration": 5, + "background": "file:///android_asset/uikit/watch.jpg", + "background_color": "#000000", + "elements": [] + } + ] + } + ] +} diff --git a/demo-app/src/main/assets/uikit/story_clock.gif b/demo-app/src/main/assets/uikit/story_clock.gif new file mode 100644 index 00000000..eb5888c3 Binary files /dev/null and b/demo-app/src/main/assets/uikit/story_clock.gif differ diff --git a/demo-app/src/main/java/com/personalization/demo/StoriesV2Compose.kt b/demo-app/src/main/java/com/personalization/demo/StoriesV2Compose.kt new file mode 100644 index 00000000..4519a1f4 --- /dev/null +++ b/demo-app/src/main/java/com/personalization/demo/StoriesV2Compose.kt @@ -0,0 +1,84 @@ +package com.personalization.demo + +import android.content.Context +import android.widget.Toast +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.material.MaterialTheme +import androidx.compose.material.OutlinedButton +import androidx.compose.material.Text +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.Modifier +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.unit.dp +import com.personalization.OnClickListener +import com.personalization.Product +import com.personalization.ui.widgets.PersonalizationStories +import com.personalization.ui.widgets.PersonalizationStoriesController +import com.personalization.ui.widgets.PersonalizationStoriesWidget + +/** + * The Compose wrapper of the Stories V2 block on the demo shop, driven by a controller (open a story + * by index — while the viewer is open it pages there), and the same block shown without the bar + * through PersonalizationStories.show(), which reports the viewer closing. + */ +@Composable +internal fun StoriesV2ComposeExhibit(storiesCode: String, shopId: String) { + val context = LocalContext.current + val controller = remember { PersonalizationStoriesController() } + var status by remember { mutableStateOf("Errors of the block and of show(), and its closing, appear here") } + val clicks = remember { DemoStoriesClicks(context) } + + Column(modifier = Modifier.fillMaxWidth(), verticalArrangement = Arrangement.spacedBy(8.dp)) { + Text( + text = "Stories V2 — Compose PersonalizationStoriesWidget with a controller", + style = MaterialTheme.typography.caption, + color = MaterialTheme.colors.onBackground.copy(alpha = 0.6f) + ) + PersonalizationStoriesWidget( + code = storiesCode, + shopId = shopId, + controller = controller, + onClickListener = clicks, + onError = { code, message -> status = "onError $code: $message" } + ) + Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) { + OutlinedButton(onClick = { controller.open(1) }) { Text("Open #2") } + OutlinedButton(onClick = { + PersonalizationStories.show( + context = context, + code = storiesCode, + shopId = shopId, + onClickListener = clicks, + onError = { code, message -> status = "show() onError $code: $message" }, + onClose = { status = "show() viewer closed" } + ) + }) { Text("Show without bar") } + } + Text(text = status, style = MaterialTheme.typography.caption) + } +} + +/** + * Logs every link and product the stories hand to the host and lets the SDK open it — the V1 + * OnClickListener contract: `true` means "SDK, open it", `false` means "the host handled it". + */ +internal class DemoStoriesClicks(private val context: Context) : OnClickListener { + override fun onClick(url: String): Boolean { + toast("Link: $url") + return false + } + + override fun onClick(product: Product): Boolean { + toast("Product: ${product.name}") + return false + } + + private fun toast(message: String) = Toast.makeText(context, message, Toast.LENGTH_SHORT).show() +} diff --git a/demo-app/src/main/java/com/personalization/demo/StoriesV2Showcase.kt b/demo-app/src/main/java/com/personalization/demo/StoriesV2Showcase.kt new file mode 100644 index 00000000..572ed4e7 --- /dev/null +++ b/demo-app/src/main/java/com/personalization/demo/StoriesV2Showcase.kt @@ -0,0 +1,326 @@ +package com.personalization.demo + +import android.content.Context +import android.content.res.Configuration +import android.graphics.Color +import android.view.View +import android.view.ViewGroup +import android.widget.FrameLayout +import android.widget.ImageView +import android.widget.LinearLayout +import androidx.appcompat.view.ContextThemeWrapper +import androidx.compose.runtime.Composable +import com.bumptech.glide.Glide +import com.personalization.stories.models.Story +import com.personalization.ui.components.PersonalizationProduct +import com.personalization.ui.components.PersonalizationStoriesBar +import com.personalization.ui.components.PersonalizationStoryCard +import com.personalization.ui.components.PersonalizationStoryCover +import com.personalization.ui.components.PersonalizationStoryItem +import com.personalization.ui.components.PersonalizationStoryNavigation +import com.personalization.ui.components.PersonalizationStoryPreview +import com.personalization.ui.components.PersonalizationStoryPrice +import com.personalization.ui.components.PersonalizationStoryTextBlock +import com.personalization.ui.components.PersonalizationStoryTimer +import com.personalization.ui.components.PersonalizationStoryUsedProducts +import com.personalization.ui.widgets.PersonalizationStories +import com.personalization.ui.widgets.PersonalizationStoriesViewer +import org.json.JSONObject + +/** + * "Stories V2" tab: the stories block drawn by the UI kit, next to the legacy one in "Stories". + * + * The first exhibit is the live block of the demo shop — it loads through the SDK like the legacy + * StoriesView. The second opens a bundled sample block (`assets/uikit/stories_sample.json`) that has + * every slide kind the kit draws — product with a discount, with a promo code, text blocks, used + * products — so the viewer can be checked without depending on what the shop's block holds today. + * The rest are the building blocks one by one. + */ +@Composable +internal fun StoriesV2Showcase(storiesCode: String, shopId: String) { + Showcase { + Exhibit("Stories V2 — live block of the demo shop") { ctx -> + PersonalizationStories(ctx).apply { + code = storiesCode + this.shopId = shopId + } + } + StoriesV2ComposeExhibit(storiesCode = storiesCode, shopId = shopId) + Exhibit( + "Stories V2 — sample block: GIF slide (8 s dial over a 5 s duration), product with the promo " + + "code of its text block (SOUND10), fitted photo with " + + "letterbox, Retry, product video slide with buttons + carousel + sound, text-block promo " + + "code, two-line labels" + ) { ctx -> ctx.sampleStories() } + Exhibit("Story Preview — pinned, default, viewed, two-line label, skeleton") { ctx -> ctx.previews() } + Exhibit("Story Cover — ring split by slides, slides 2 and 4 seen; pinned with slide 1 seen") { ctx -> + ctx.row( + PersonalizationStoryCover(ctx).apply { + segments = 5 + seenSegments = setOf(1, 3) + ctx.loadAsset(imageView, "sneakers.jpg") + }, + PersonalizationStoryCover(ctx).apply { + segments = 3 + seenSegments = setOf(0) + state = PersonalizationStoryCover.State.PINNED + ctx.loadAsset(imageView, "watch.jpg") + } + ) + } + Exhibit("Stories Bar — loading") { ctx -> PersonalizationStoriesBar(ctx).apply { showSkeleton() } } + Exhibit("Story Navigation — slide 2 of 5, over a photo (dark tokens)") { ctx -> + val dark = ctx.darkContext() + ctx.overPhoto( + "jacket.jpg", + PersonalizationStoryNavigation(dark).apply { + progress.count = 5 + progress.current = 1 + progress.progress = 0.5f + onClose = { ctx.toast("Close") } + }, + heightDp = 96 + ) + } + Exhibit("Story Price — price, discount, promo code (tap to copy), long code") { ctx -> ctx.prices() } + Exhibit("Story Timer — merged, separate") { ctx -> + val end = System.currentTimeMillis() + ((2 * 24 + 18) * 3600L + 33 * 60 + 24) * 1000 + ctx.column( + PersonalizationStoryTimer(ctx).apply { endTimeMillis = end }, + PersonalizationStoryTimer(ctx).apply { + style = PersonalizationStoryTimer.Style.SEPARATE + endTimeMillis = end + } + ) + } + Exhibit("Story Text Block — solid large / medium / small, transparent") { ctx -> ctx.textBlocks() } + Exhibit("Story Used Products — collapsed with sound, expanded (dark tokens)") { ctx -> ctx.usedProducts() } + Exhibit("Story Card — product with a discount, as on a slide") { ctx -> + ctx.slideFrame(ctx.storyCard(action = false), photo = null) + } + Exhibit("Story Card — action over a photo: badge, timer, no image (dark tokens)") { ctx -> + ctx.slideFrame(ctx.darkContext().storyCard(action = true), photo = "backpack.jpg") + } + } +} + +// --- Exhibits ----------------------------------------------------------------------------------- + +private fun Context.sampleStories(): View { + val json = assets.open("uikit/stories_sample.json").bufferedReader().use { it.readText() } + val array = JSONObject(json).getJSONArray("stories") + val stories = List(array.length()) { Story(array.getJSONObject(it)) } + val bar = PersonalizationStoriesBar(this) + fun render() { + bar.items = stories.map { story -> + PersonalizationStoryItem( + id = story.id.toString(), + title = story.name, + imageUrl = story.avatar, + state = when { + story.isPinned -> PersonalizationStoryCover.State.PINNED + story.isViewed -> PersonalizationStoryCover.State.VIEWED + else -> PersonalizationStoryCover.State.DEFAULT + }, + segments = story.slidesCount, + seenSegments = if (story.isViewed) emptySet() else (0 until story.startPosition).toSet() + ) + } + } + // Like the SDK default: a GIF cover stays on its first frame, only the slide plays it. + bar.imageLoader = { view, url -> Glide.with(view).asBitmap().load(url).into(view) } + bar.onItemClick = { index, _ -> + PersonalizationStoriesViewer(this, stories, index).apply { + onClickListener = DemoStoriesClicks(this@sampleStories) + setOnDismissListener { render() } + show() + } + } + render() + return bar +} + +private fun Context.previews(): View { + fun preview(title: String, state: PersonalizationStoryCover.State, asset: String?) = + PersonalizationStoryPreview(this).apply { + this.title = title + this.state = state + asset?.let { loadAsset(cover.imageView, it) } + } + return hscrollRow( + preview("Pinned", PersonalizationStoryCover.State.PINNED, "sneakers.jpg"), + preview("Default", PersonalizationStoryCover.State.DEFAULT, "jacket.jpg"), + preview("Viewed", PersonalizationStoryCover.State.VIEWED, "watch.jpg"), + preview("Two-line label that is cut at the end", PersonalizationStoryCover.State.DEFAULT, "bottle.jpg"), + preview("", PersonalizationStoryCover.State.SKELETON, null) + ) +} + +private fun Context.prices(): View { + fun price(type: PersonalizationStoryPrice.Type, promo: String? = null) = PersonalizationStoryPrice(this).apply { + this.type = type + price = "1 190 900 ₽" + oldPrice = "245 000 ₽" + discount = "10%" + promoCode = promo + onPromoCopied = { toast("Copied: $it") } + } + return column( + price(PersonalizationStoryPrice.Type.PRICE).apply { oldPrice = null }, + price(PersonalizationStoryPrice.Type.PRICE), + price(PersonalizationStoryPrice.Type.DISCOUNT), + price(PersonalizationStoryPrice.Type.PROMO_CODE, "PROMO"), + price(PersonalizationStoryPrice.Type.PROMO_CODE, "YAGODA-MALINA") + ) +} + +private fun Context.textBlocks(): View { + val dark = darkContext() + fun block(size: PersonalizationStoryTextBlock.Size, color: Int?, align: PersonalizationStoryTextBlock.Align = PersonalizationStoryTextBlock.Align.START) = + PersonalizationStoryTextBlock(dark).apply { + text = "Open eat dear winding belonging." + this.size = size + blockColor = color + this.align = align + } + val stack = LinearLayout(dark).apply { + orientation = LinearLayout.VERTICAL + setPadding(dp(16), dp(16), dp(16), dp(16)) + listOf( + block(PersonalizationStoryTextBlock.Size.LARGE, Color.parseColor("#1BAA1B")), + block(PersonalizationStoryTextBlock.Size.MEDIUM, Color.parseColor("#F37A17")), + block(PersonalizationStoryTextBlock.Size.SMALL, Color.parseColor("#0087E8")), + block(PersonalizationStoryTextBlock.Size.LARGE, null), + block(PersonalizationStoryTextBlock.Size.MEDIUM, null, PersonalizationStoryTextBlock.Align.CENTER), + block(PersonalizationStoryTextBlock.Size.SMALL, null, PersonalizationStoryTextBlock.Align.END) + ).forEachIndexed { index, view -> + addView(view, LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT).apply { + if (index > 0) topMargin = dp(16) + }) + } + } + return overPhoto("bottle.jpg", stack, heightDp = null) +} + +private fun Context.usedProducts(): View { + val dark = darkContext() + val products = listOf( + PersonalizationProduct("4", "Рюкзак городской Trail 20 л", "4 990 ₽", "file:///android_asset/uikit/backpack.jpg", "Trail", oldPrice = "5 990 ₽", discount = "-17%"), + PersonalizationProduct("5", "Очки солнцезащитные Sunny", "2 990 ₽", "file:///android_asset/uikit/sunglasses.jpg", "Sunny"), + PersonalizationProduct("6", "Бутылка для воды Aqua 0,75 л", "990 ₽", "file:///android_asset/uikit/bottle.jpg", "Aqua") + ) + fun used(expanded: Boolean) = PersonalizationStoryUsedProducts(dark).apply { + this.products = products + showText = "Используемые товары" + hideText = "Скрыть товары" + imageLoader = { view, product -> product.imageUrl?.let { Glide.with(view).load(it).into(view) } } + onProductClick = { toast(it.name.toString()) } + showSoundButton = true + onSoundClick = { muted = !muted } + this.expanded = expanded + } + return column( + overPhoto("jacket.jpg", used(expanded = false), heightDp = null), + overPhoto("jacket.jpg", used(expanded = true), heightDp = null) + ) +} + +private fun Context.storyCard(action: Boolean): PersonalizationStoryCard = PersonalizationStoryCard(this).apply { + if (action) { + badgeText = "Sale!" + title = "Скидки до 10%!" + subtitle = "На рюкзаки и сумки до конца недели" + showImage = false + showTimer = true + timer.endTimeMillis = System.currentTimeMillis() + 3 * 24 * 3600 * 1000L + price.type = PersonalizationStoryPrice.Type.DISCOUNT + price.discount = "10%" + } else { + title = "Pegasus" + subtitle = "Кроссовки беговые Pegasus 41, сетчатый верх" + loadAsset(imageView, "sneakers.jpg") + price.type = PersonalizationStoryPrice.Type.DISCOUNT + price.discount = "23%" + } + price.price = "9 990 ₽" + price.oldPrice = "12 990 ₽" + buttonText = "More info" + onButtonClick = { toast("More info") } +} + +// --- Helpers ------------------------------------------------------------------------------------ + +/** + * The kit draws media slides with its dark tokens; the SDK keeps its helper internal, so the demo + * forces night resources on a subtree the same way to show those exhibits as they appear in a story. + */ +private fun Context.darkContext(): Context { + val configuration = Configuration(resources.configuration).apply { + uiMode = (uiMode and Configuration.UI_MODE_NIGHT_MASK.inv()) or Configuration.UI_MODE_NIGHT_YES + } + return ContextThemeWrapper(this, theme).apply { applyOverrideConfiguration(configuration) } +} + +/** Decoded straight from the APK — Glide in a Compose-hosted view may never get its pre-draw. */ +private fun Context.loadAsset(view: ImageView, name: String) { + view.setImageBitmap(assetBitmap("uikit/$name")) +} + +/** An exhibit over a photo, the way the component sits on a media slide. */ +private fun Context.overPhoto(asset: String, content: View, heightDp: Int?): View = fixedHeight(heightDp, FrameLayout(this).apply { + addView(ImageView(context).apply { + scaleType = ImageView.ScaleType.CENTER_CROP + loadAsset(this, asset) + }, FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)) + addView(View(context).apply { setBackgroundColor(Color.argb(77, 0, 0, 0)) }, + FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)) + addView(content, FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT).apply { + if (heightDp != null) setMargins(dp(16), dp(16), dp(16), dp(16)) + }) +}) + +/** A card at a phone-slide size, on the kit background or over a photo. */ +private fun Context.slideFrame(card: View, photo: String?): View = fixedHeight(SLIDE_HEIGHT_DP, FrameLayout(this).apply { + if (photo != null) { + addView(ImageView(context).apply { + scaleType = ImageView.ScaleType.CENTER_CROP + loadAsset(this, photo) + }, FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)) + addView(View(context).apply { setBackgroundColor(Color.argb(77, 0, 0, 0)) }, + FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)) + } else { + setBackgroundColor(com.personalization.ui.PersonalizationTheme.color(context, com.personalization.R.color.personalization_background_card)) + } + setPadding(dp(16), dp(16), dp(16), dp(16)) + addView(card, FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)) +}) + +/** + * Wraps [content] at a fixed height: AndroidView owns the layout params of the view it hosts, so the + * height has to live on a child of it. + */ +private fun Context.fixedHeight(heightDp: Int?, content: View): View { + if (heightDp == null) return content + return FrameLayout(this).apply { + addView(content, FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, dp(heightDp))) + } +} + +/** A slide of the design is 402×874; the exhibit keeps the card at a phone-like height. */ +private const val SLIDE_HEIGHT_DP = 620 + +private fun Context.hscrollRow(vararg children: View): View = + android.widget.HorizontalScrollView(this).apply { + isHorizontalScrollBarEnabled = false + addView(LinearLayout(context).apply { + orientation = LinearLayout.HORIZONTAL + children.forEachIndexed { index, child -> + addView(child, LinearLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT).apply { + if (index > 0) marginStart = dp(16) + }) + } + }) + } + +private fun Context.toast(message: String) = + android.widget.Toast.makeText(this, message, android.widget.Toast.LENGTH_SHORT).show() diff --git a/demo-app/src/main/java/com/personalization/demo/UiKitPane.kt b/demo-app/src/main/java/com/personalization/demo/UiKitPane.kt index 66398640..d6d19e8d 100644 --- a/demo-app/src/main/java/com/personalization/demo/UiKitPane.kt +++ b/demo-app/src/main/java/com/personalization/demo/UiKitPane.kt @@ -26,7 +26,7 @@ import androidx.compose.foundation.rememberScrollState import androidx.compose.foundation.verticalScroll import androidx.compose.material.MaterialTheme import androidx.compose.material.Tab -import androidx.compose.material.TabRow +import androidx.compose.material.ScrollableTabRow import androidx.compose.material.Text import androidx.compose.material.TextButton import androidx.compose.runtime.Composable @@ -84,6 +84,7 @@ import com.personalization.ui.widgets.PersonalizationSearchResultsScreen * search, the catalogue, the filters screen). "Search" runs the two data-bound search widgets against * the demo shop: the instant search field, and the results screen it opens on submit. "Stories" keeps * the stories block through the SDK's Compose wrapper, the counterpart of the "Legacy UI" tab. + * "Stories V2" is the same block drawn by the kit (see [StoriesV2Showcase]). * * The kit is classic Views, so each exhibit is an [AndroidView] built from a small factory. Product * data is static: the kit does not fetch or format anything itself, and images are loaded by the @@ -92,7 +93,7 @@ import com.personalization.ui.widgets.PersonalizationSearchResultsScreen @Composable fun UiKitPane(storiesCode: String, shopId: String) { var tab by rememberSaveable { mutableStateOf(0) } - val tabs = listOf("Components", "Blocks", "Search", "Stories") + val tabs = listOf("Components", "Blocks", "Search", "Stories", "Stories V2") Column(modifier = Modifier.fillMaxSize()) { Row( @@ -101,7 +102,8 @@ fun UiKitPane(storiesCode: String, shopId: String) { ) { AppearanceSwitch() } - TabRow( + // Five tabs do not fit a fixed row on a phone: the labels would break mid-word. + ScrollableTabRow( selectedTabIndex = tab, backgroundColor = MaterialTheme.colors.surface, contentColor = MaterialTheme.colors.primary @@ -114,7 +116,8 @@ fun UiKitPane(storiesCode: String, shopId: String) { 0 -> ComponentsShowcase() 1 -> BlocksShowcase() 2 -> SearchShowcase(shopId = shopId) - else -> ComposeStoriesPane(code = storiesCode, shopId = shopId) + 3 -> ComposeStoriesPane(code = storiesCode, shopId = shopId) + else -> StoriesV2Showcase(storiesCode = storiesCode, shopId = shopId) } } } @@ -409,7 +412,7 @@ private fun Context.loyaltyCard(stamps: Int, brand: Int? = null): View { } /** Decoded straight from the APK: Glide waits for a pre-draw that Compose-hosted views may never get. */ -private fun Context.assetBitmap(path: String): Bitmap = assets.open(path).use(BitmapFactory::decodeStream) +internal fun Context.assetBitmap(path: String): Bitmap = assets.open(path).use(BitmapFactory::decodeStream) /** * The popup as the SDK will hand it over: the host loads the image and wires the two callbacks. @@ -517,7 +520,7 @@ private fun Context.toast(message: String) = Toast.makeText(this, message, Toast // --- Compose scaffolding ------------------------------------------------------------------------ @Composable -private fun Showcase(content: @Composable () -> Unit) { +internal fun Showcase(content: @Composable () -> Unit) { Column( modifier = Modifier .fillMaxSize() @@ -529,7 +532,7 @@ private fun Showcase(content: @Composable () -> Unit) { } @Composable -private fun Exhibit(title: String, build: (Context) -> View) { +internal fun Exhibit(title: String, build: (Context) -> View) { Column(modifier = Modifier.fillMaxWidth(), verticalArrangement = Arrangement.spacedBy(8.dp)) { Text( text = title, @@ -542,9 +545,9 @@ private fun Exhibit(title: String, build: (Context) -> View) { // --- View factories ----------------------------------------------------------------------------- -private fun Context.dp(value: Int): Int = (value * resources.displayMetrics.density).toInt() +internal fun Context.dp(value: Int): Int = (value * resources.displayMetrics.density).toInt() -private fun Context.row(vararg children: View): LinearLayout = LinearLayout(this).apply { +internal fun Context.row(vararg children: View): LinearLayout = LinearLayout(this).apply { orientation = LinearLayout.HORIZONTAL gravity = Gravity.CENTER_VERTICAL children.forEachIndexed { index, child -> @@ -555,7 +558,7 @@ private fun Context.row(vararg children: View): LinearLayout = LinearLayout(this } } -private fun Context.column(vararg children: View): LinearLayout = LinearLayout(this).apply { +internal fun Context.column(vararg children: View): LinearLayout = LinearLayout(this).apply { orientation = LinearLayout.VERTICAL children.forEachIndexed { index, child -> val params = (child.layoutParams as? LinearLayout.LayoutParams) diff --git a/personalization-sdk/src/main/kotlin/com/personalization/Product.kt b/personalization-sdk/src/main/kotlin/com/personalization/Product.kt index e644bd4c..69252d94 100644 --- a/personalization-sdk/src/main/kotlin/com/personalization/Product.kt +++ b/personalization-sdk/src/main/kotlin/com/personalization/Product.kt @@ -1,5 +1,6 @@ package com.personalization +import java.math.BigDecimal import org.json.JSONObject class Product(json: JSONObject) { @@ -16,6 +17,15 @@ class Product(json: JSONObject) { val priceWithPromocode: String = json.optString("price_with_promocode_formatted", "") val discountPercent: String = json.optString("discount_percent", "") + /** + * Raw numeric prices, for comparing them (Stories V2 shows an old price only when it is greater + * than the price). `null` when the field is absent or not a number. Read as decimals: a price may + * have kopecks/cents, and an Int would silently drop them. + */ + internal val priceDecimal: BigDecimal? = json.decimal("price") + internal val oldPriceDecimal: BigDecimal? = json.decimal("oldprice") + internal val priceWithPromocodeDecimal: BigDecimal? = json.decimal("price_with_promocode") + init { val oldPriceValue = json.optDouble("oldprice", 0.0) oldPrice = if (oldPriceValue > 0) { @@ -31,3 +41,6 @@ class Product(json: JSONObject) { } } } + +private fun JSONObject.decimal(name: String): BigDecimal? = + opt(name)?.takeIf { it != JSONObject.NULL }?.toString()?.trim()?.toBigDecimalOrNull() diff --git a/personalization-sdk/src/main/kotlin/com/personalization/stories/models/Slide.kt b/personalization-sdk/src/main/kotlin/com/personalization/stories/models/Slide.kt index a8254f65..2272fbf9 100644 --- a/personalization-sdk/src/main/kotlin/com/personalization/stories/models/Slide.kt +++ b/personalization-sdk/src/main/kotlin/com/personalization/stories/models/Slide.kt @@ -17,6 +17,12 @@ class Slide(json: JSONObject) : Serializable { val preview: String = json.optString("preview", "") val type: String = json.optString("type", "") var duration: Long = json.optLong("duration", DEFAULT_DURATION_SECONDS.toLong()) * 1000L + + /** + * The admin duration in seconds as sent, 0 when absent. [duration] already folds a default in, + * so Stories V2 reads this one to apply its own default. + */ + internal val adminDurationSeconds: Long = json.optLong("duration", 0L) private val elements: MutableList = ArrayList() var isPrepared: Boolean = false diff --git a/personalization-sdk/src/main/kotlin/com/personalization/ui/PersonalizationTheme.kt b/personalization-sdk/src/main/kotlin/com/personalization/ui/PersonalizationTheme.kt index 44c2835f..b7707e4d 100644 --- a/personalization-sdk/src/main/kotlin/com/personalization/ui/PersonalizationTheme.kt +++ b/personalization-sdk/src/main/kotlin/com/personalization/ui/PersonalizationTheme.kt @@ -41,6 +41,9 @@ object PersonalizationTheme { R.color.personalization_neutral_50 to R.attr.personalizationColorNeutral50, R.color.personalization_semantic_warning to R.attr.personalizationColorSemanticWarning, R.color.personalization_semantic_danger to R.attr.personalizationColorSemanticDanger, + R.color.personalization_neutral_100 to R.attr.personalizationColorNeutral100, + R.color.personalization_semantic_info to R.attr.personalizationColorSemanticInfo, + R.color.personalization_semantic_neutral_subtle to R.attr.personalizationColorSemanticNeutralSubtle, R.color.personalization_background_generic to R.attr.personalizationColorBackgroundGeneric, R.color.personalization_background_card to R.attr.personalizationColorBackgroundCard, R.color.personalization_background_input to R.attr.personalizationColorBackgroundInput, diff --git a/personalization-sdk/src/main/kotlin/com/personalization/ui/components/PersonalizationStoryCard.kt b/personalization-sdk/src/main/kotlin/com/personalization/ui/components/PersonalizationStoryCard.kt new file mode 100644 index 00000000..4169a5e9 --- /dev/null +++ b/personalization-sdk/src/main/kotlin/com/personalization/ui/components/PersonalizationStoryCard.kt @@ -0,0 +1,217 @@ +package com.personalization.ui.components + +import android.content.Context +import android.graphics.drawable.GradientDrawable +import android.util.AttributeSet +import android.util.TypedValue +import android.view.Gravity +import android.view.View +import android.widget.FrameLayout +import android.widget.ImageView +import android.widget.LinearLayout +import androidx.appcompat.widget.AppCompatImageView +import androidx.appcompat.widget.AppCompatTextView +import com.personalization.R +import com.personalization.ui.InternalPersonalizationUiApi +import com.personalization.ui.PersonalizationTheme + +/** + * Содержимое товарного и акционного слайда. + * + * Источник: Figma, Card/Story (238:6890), виды Product / Promo / Discount / Action: + * колонка, разнесённая по высоте. Сверху бейдж ([badgeText], Badge LG) и шапка — + * [title] SemiBold 20 и [subtitle] SemiBold 16 с интерлиньяжем 140% и шагом 8. + * Посередине — белая квадратная карточка фото со скруглением 12 и отступом 16 + * ([showImage]); квадрат вписывается в свободную высоту. Снизу с шагом 16 — + * [price], [timer] и кнопка LG Primary ([buttonText]). + * + * Цвет текста шапки — Text/Primary контекста: на медиа-слайде он тёмный режим. + */ +@InternalPersonalizationUiApi +class PersonalizationStoryCard @JvmOverloads constructor( + context: Context, + attrs: AttributeSet? = null, + defStyleAttr: Int = 0 +) : LinearLayout(context, attrs, defStyleAttr) { + + val badge = PersonalizationBadge(context) + val price = PersonalizationStoryPrice(context) + val timer = PersonalizationStoryTimer(context) + val button = PersonalizationButton(context) + + /** Фото товара — хост кладёт картинку своим загрузчиком. */ + val imageView: ImageView = AppCompatImageView(context) + + private val header = LinearLayout(context) + private val titleView = AppCompatTextView(context) + private val subtitleView = AppCompatTextView(context) + private val imageArea = FrameLayout(context) + private val imageCard = StorySquareFrame(context) + private val spacer = View(context) + private val bottom = LinearLayout(context) + + var badgeText: CharSequence? = null + set(value) { + field = value + badge.text = value + applyVisibility() + } + + var title: CharSequence? = null + set(value) { + field = value + titleView.text = value + applyVisibility() + } + + var subtitle: CharSequence? = null + set(value) { + field = value + subtitleView.text = value + applyVisibility() + } + + var showImage: Boolean = true + set(value) { + field = value + applyVisibility() + } + + var showPrice: Boolean = true + set(value) { + field = value + applyVisibility() + } + + var showTimer: Boolean = false + set(value) { + field = value + applyVisibility() + } + + /** Подпись кнопки; `null` — без кнопки. */ + var buttonText: CharSequence? = null + set(value) { + field = value + button.text = value + applyVisibility() + } + + var onButtonClick: (() -> Unit)? = null + + /** Тап по фото товара; `null` — фото не нажимается, и касания уходят под карточку. */ + var onImageClick: (() -> Unit)? = null + set(value) { + field = value + if (value == null) { + imageCard.setOnClickListener(null) + imageCard.isClickable = false + } else { + imageCard.setOnClickListener { onImageClick?.invoke() } + } + } + + init { + orientation = VERTICAL + + badge.size = PersonalizationBadge.Size.LG + badge.badgeView = PersonalizationBadge.BadgeView.WARNING + addView(badge, LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT).apply { + bottomMargin = dp(16) + }) + + header.orientation = VERTICAL + titleView.headerStyle(20f) + subtitleView.headerStyle(16f) + header.addView(titleView, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT)) + header.addView(subtitleView, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT).apply { + topMargin = dp(8) + }) + addView(header, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT)) + + imageCard.background = GradientDrawable().apply { + cornerRadius = dp(12).toFloat() + setColor(IMAGE_CARD_COLOR) + } + imageCard.setPadding(dp(16), dp(16), dp(16), dp(16)) + (imageView as AppCompatImageView).scaleType = ImageView.ScaleType.FIT_CENTER + imageCard.addView(imageView, FrameLayout.LayoutParams(FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT)) + imageArea.setPadding(0, dp(16), 0, dp(16)) + imageArea.addView( + imageCard, + FrameLayout.LayoutParams(FrameLayout.LayoutParams.WRAP_CONTENT, FrameLayout.LayoutParams.WRAP_CONTENT, Gravity.CENTER) + ) + addView(imageArea, LayoutParams(LayoutParams.MATCH_PARENT, 0, 1f)) + addView(spacer, LayoutParams(LayoutParams.MATCH_PARENT, 0, 1f)) + + bottom.orientation = VERTICAL + bottom.addView(price, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT)) + bottom.addView(timer, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT).apply { + topMargin = dp(16) + }) + button.size = PersonalizationButton.Size.LG + button.buttonView = PersonalizationButton.ButtonView.PRIMARY + button.setOnClickListener { onButtonClick?.invoke() } + bottom.addView(button, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT).apply { + topMargin = dp(16) + }) + addView(bottom, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT)) + + applyVisibility() + } + + private fun applyVisibility() { + badge.visibility = visibleIf(!badgeText.isNullOrEmpty()) + titleView.visibility = visibleIf(!title.isNullOrEmpty()) + subtitleView.visibility = visibleIf(!subtitle.isNullOrEmpty()) + (subtitleView.layoutParams as LayoutParams).topMargin = if (title.isNullOrEmpty()) 0 else dp(8) + header.visibility = visibleIf(!title.isNullOrEmpty() || !subtitle.isNullOrEmpty()) + imageArea.visibility = visibleIf(showImage) + spacer.visibility = visibleIf(!showImage) + price.visibility = visibleIf(showPrice) + timer.visibility = visibleIf(showTimer) + button.visibility = visibleIf(!buttonText.isNullOrEmpty()) + + // Шаг 16 только между видимыми элементами низа. + var first = true + for (child in listOf(price, timer, button)) { + if (child.visibility != View.VISIBLE) continue + (child.layoutParams as LayoutParams).topMargin = if (first) 0 else dp(16) + first = false + } + requestLayout() + } + + private fun AppCompatTextView.headerStyle(sizeSp: Float) { + includeFontPadding = false + typeface = PersonalizationTheme.typeface(context, emphasized = true) + setTextSize(TypedValue.COMPLEX_UNIT_SP, sizeSp) + setLineSpacing(0f, HEADER_LINE_HEIGHT) + setTextColor(PersonalizationTheme.color(context, R.color.personalization_text_primary)) + } + + private fun visibleIf(visible: Boolean) = if (visible) View.VISIBLE else View.GONE + + private fun dp(value: Int): Int = (value * resources.displayMetrics.density).toInt() + + private companion object { + /** Карточка фото в макете белая в обеих темах — фото товаров снимают на белом. */ + const val IMAGE_CARD_COLOR = 0xFFFFFFFF.toInt() + const val HEADER_LINE_HEIGHT = 1.4f + } +} + +/** Квадрат, вписанный в отведённое место: сторона — меньшая из ширины и высоты. */ +internal class StorySquareFrame(context: Context) : FrameLayout(context) { + override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) { + val width = MeasureSpec.getSize(widthMeasureSpec) + val height = MeasureSpec.getSize(heightMeasureSpec) + val side = when { + MeasureSpec.getMode(heightMeasureSpec) == MeasureSpec.UNSPECIFIED -> width + MeasureSpec.getMode(widthMeasureSpec) == MeasureSpec.UNSPECIFIED -> height + else -> minOf(width, height) + } + val exact = MeasureSpec.makeMeasureSpec(side, MeasureSpec.EXACTLY) + super.onMeasure(exact, exact) + } +} diff --git a/personalization-sdk/src/main/kotlin/com/personalization/ui/components/PersonalizationStoryCover.kt b/personalization-sdk/src/main/kotlin/com/personalization/ui/components/PersonalizationStoryCover.kt new file mode 100644 index 00000000..671a1029 --- /dev/null +++ b/personalization-sdk/src/main/kotlin/com/personalization/ui/components/PersonalizationStoryCover.kt @@ -0,0 +1,367 @@ +package com.personalization.ui.components + +import android.content.Context +import android.graphics.Canvas +import android.graphics.Paint +import android.graphics.RectF +import android.graphics.drawable.GradientDrawable +import android.text.TextUtils +import android.util.AttributeSet +import android.util.TypedValue +import android.view.Gravity +import android.view.View +import android.widget.FrameLayout +import android.widget.HorizontalScrollView +import android.widget.ImageView +import android.widget.LinearLayout +import androidx.appcompat.widget.AppCompatImageView +import androidx.appcompat.widget.AppCompatTextView +import androidx.core.widget.ImageViewCompat +import androidx.core.widget.TextViewCompat +import com.personalization.R +import com.personalization.ui.InternalPersonalizationUiApi +import com.personalization.ui.PersonalizationTheme + +/** + * Обложка сторис в ленте: кольцо и круглая картинка. + * + * Источник: Figma Mobile SDK UI Kit, Story/Cover (393:17570) и Progress/Circular (391:17122): + * круг 88 с кольцом 4 внутрь, картинка 76 с зазором 2 от кольца. Состояния — [State]: + * закреплённая (кольцо Semantic/Warning и звезда Favorites справа внизу), обычная + * (Button/Primary), просмотренная (Semantic/Neutral Subtle) и скелетон загрузки. + * + * Кольцо делится на сегменты по числу слайдов ([segments]); просмотренные слайды + * ([seenSegments], по индексу) — цветом Button/Primary Disabled, как в вариантах + * Progress/Circular. + * + * Картинку кладёт хост в [imageView] — кит ничего не качает. + */ +@InternalPersonalizationUiApi +class PersonalizationStoryCover @JvmOverloads constructor( + context: Context, + attrs: AttributeSet? = null, + defStyleAttr: Int = 0 +) : FrameLayout(context, attrs, defStyleAttr) { + + enum class State { PINNED, DEFAULT, VIEWED, SKELETON } + + var state: State = State.DEFAULT + set(value) { + field = value + applyState() + } + + /** Сколько сегментов у кольца — обычно число слайдов. 1 — сплошное кольцо. */ + var segments: Int = 1 + set(value) { + field = value.coerceAtLeast(1) + invalidate() + } + + /** Индексы просмотренных сегментов: сегмент i отмечен, если виден слайд i. */ + var seenSegments: Set = emptySet() + set(value) { + field = value + invalidate() + } + + /** Диаметр обложки в пикселях; толщина кольца и зазор не масштабируются. */ + var coverSize: Int = dp(DEFAULT_SIZE_DP) + set(value) { + field = value + requestLayout() + } + + /** Круглая картинка обложки. */ + val imageView: ImageView = StoryCircleImageView(context) + + private val favorites = FrameLayout(context) + private val star = AppCompatImageView(context) + private val ringPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { + style = Paint.Style.STROKE + strokeWidth = dp(RING_DP).toFloat() + } + private val ringBounds = RectF() + + init { + setWillNotDraw(false) + clipChildren = false + + addView(imageView, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)) + + star.setImageResource(R.drawable.personalization_ic_star_fill) + ImageViewCompat.setImageTintList( + star, + PersonalizationTheme.colorStateList(context, R.color.personalization_text_light_primary) + ) + favorites.background = GradientDrawable().apply { + shape = GradientDrawable.OVAL + setColor(PersonalizationTheme.color(context, R.color.personalization_semantic_warning)) + } + favorites.addView(star, LayoutParams(dp(STAR_DP), dp(STAR_DP), Gravity.CENTER)) + addView(favorites, LayoutParams(dp(FAVORITES_DP), dp(FAVORITES_DP), Gravity.BOTTOM or Gravity.END)) + + applyState() + } + + override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) { + val inset = dp(RING_DP + GAP_DP) + val image = MeasureSpec.makeMeasureSpec(coverSize - inset * 2, MeasureSpec.EXACTLY) + imageView.measure(image, image) + val badge = MeasureSpec.makeMeasureSpec(dp(FAVORITES_DP), MeasureSpec.EXACTLY) + favorites.measure(badge, badge) + setMeasuredDimension(coverSize, coverSize) + } + + override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) { + val inset = dp(RING_DP + GAP_DP) + imageView.layout(inset, inset, coverSize - inset, coverSize - inset) + // В макете звезда стоит в 62,62 при обложке 88 — прижата к правому нижнему углу + // с отступом 2 от края. + val badgeEnd = coverSize - dp(FAVORITES_INSET_DP) + favorites.layout(badgeEnd - dp(FAVORITES_DP), badgeEnd - dp(FAVORITES_DP), badgeEnd, badgeEnd) + } + + override fun onDraw(canvas: Canvas) { + super.onDraw(canvas) + val half = ringPaint.strokeWidth / 2f + ringBounds.set(half, half, width - half, height - half) + + if (state == State.SKELETON) { + ringPaint.shader = StorySupport.skeletonShader(context, width.toFloat(), height.toFloat()) + canvas.drawOval(ringBounds, ringPaint) + ringPaint.shader = null + return + } + + val main = PersonalizationTheme.color(context, ringColorRes()) + if (segments <= 1 || state == State.VIEWED) { + ringPaint.color = main + canvas.drawOval(ringBounds, ringPaint) + return + } + + val seen = PersonalizationTheme.color(context, R.color.personalization_button_primary_disabled) + val sweep = 360f / segments + val gap = SEGMENT_GAP_DEGREES.coerceAtMost(sweep / 3f) + for (index in 0 until segments) { + ringPaint.color = if (index in seenSegments) seen else main + canvas.drawArc(ringBounds, START_ANGLE + index * sweep + gap / 2f, sweep - gap, false, ringPaint) + } + } + + private fun ringColorRes(): Int = when (state) { + State.PINNED -> R.color.personalization_semantic_warning + State.VIEWED -> R.color.personalization_semantic_neutral_subtle + else -> R.color.personalization_button_primary + } + + private fun applyState() { + val skeleton = state == State.SKELETON + imageView.background = if (skeleton) StorySupport.skeletonDrawable(context, GradientDrawable.OVAL) else null + imageView.visibility = View.VISIBLE + if (skeleton) imageView.setImageDrawable(null) + favorites.visibility = if (state == State.PINNED) View.VISIBLE else View.GONE + invalidate() + } + + private fun dp(value: Int): Int = (value * resources.displayMetrics.density).toInt() + + private companion object { + const val DEFAULT_SIZE_DP = 88 + const val RING_DP = 4 + const val GAP_DP = 2 + const val FAVORITES_DP = 24 + const val FAVORITES_INSET_DP = 2 + const val STAR_DP = 16 + const val START_ANGLE = -90f + const val SEGMENT_GAP_DEGREES = 8f + } +} + +/** + * Превью сторис: обложка и подпись под ней. + * + * Источник: Figma, Story/Preview (391:17082): колонка шириной с обложку, шаг 8, + * подпись Regular 12/16 по центру цветом Text/Primary — до двух строк с многоточием + * в конце, как у старых сторис. У скелетона вместо подписи — полоска 64×8 со скруглением 5. + */ +@InternalPersonalizationUiApi +class PersonalizationStoryPreview @JvmOverloads constructor( + context: Context, + attrs: AttributeSet? = null, + defStyleAttr: Int = 0 +) : LinearLayout(context, attrs, defStyleAttr) { + + val cover = PersonalizationStoryCover(context) + + private val label = AppCompatTextView(context) + private val skeletonLabel = View(context) + + var title: CharSequence? + get() = label.text + set(value) { + label.text = value + } + + var state: PersonalizationStoryCover.State + get() = cover.state + set(value) { + cover.state = value + applyState() + } + + init { + orientation = VERTICAL + gravity = Gravity.CENTER_HORIZONTAL + + addView(cover, LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT)) + + label.includeFontPadding = false + label.gravity = Gravity.CENTER + label.maxLines = LABEL_MAX_LINES + label.ellipsize = TextUtils.TruncateAt.END + label.typeface = PersonalizationTheme.typeface(context, emphasized = false) + label.setTextSize(TypedValue.COMPLEX_UNIT_PX, resources.getDimension(R.dimen.personalization_font_size_xs)) + TextViewCompat.setLineHeight(label, resources.getDimensionPixelSize(R.dimen.personalization_line_height_xs)) + label.setLetterSpacingCompat(LABEL_LETTER_SPACING_EM) + label.setTextColor(PersonalizationTheme.color(context, R.color.personalization_text_primary)) + addView( + label, + LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT).apply { + topMargin = resources.getDimensionPixelSize(R.dimen.personalization_spacing_md) + } + ) + + skeletonLabel.background = StorySupport.skeletonDrawable(context, GradientDrawable.RECTANGLE, dp(5).toFloat()) + addView( + skeletonLabel, + LayoutParams(dp(64), dp(8)).apply { + // Полоска 8 в строке 16: по 4 сверху и снизу. + topMargin = resources.getDimensionPixelSize(R.dimen.personalization_spacing_md) + dp(4) + bottomMargin = dp(4) + } + ) + applyState() + } + + override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) { + // Ширина превью — ширина обложки, длинная подпись режется многоточием на второй строке. + super.onMeasure(MeasureSpec.makeMeasureSpec(cover.coverSize, MeasureSpec.EXACTLY), heightMeasureSpec) + } + + private fun applyState() { + val skeleton = cover.state == PersonalizationStoryCover.State.SKELETON + label.visibility = if (skeleton) View.GONE else View.VISIBLE + skeletonLabel.visibility = if (skeleton) View.VISIBLE else View.GONE + } + + private fun dp(value: Int): Int = (value * resources.displayMetrics.density).toInt() + + private companion object { + /** Трекинг в макете 0.05 — в процентах кегля, то есть почти ноль; в em так же. */ + const val LABEL_LETTER_SPACING_EM = 0.0005f + const val LABEL_MAX_LINES = 2 + } +} + +/** Сторис для ленты: всё, что нужно обложке и подписи. */ +@InternalPersonalizationUiApi +data class PersonalizationStoryItem( + val id: String, + val title: CharSequence, + val imageUrl: String? = null, + val state: PersonalizationStoryCover.State = PersonalizationStoryCover.State.DEFAULT, + val segments: Int = 1, + /** Индексы просмотренных слайдов — отмечаются на кольце. */ + val seenSegments: Set = emptySet() +) + +/** + * Лента сторис — горизонтальный ряд превью. + * + * Источник: Figma, Card/Story View=Stories Block (238:6890): превью с шагом 16, + * отступы 16. Пока данных нет — [showSkeleton]. + */ +@InternalPersonalizationUiApi +class PersonalizationStoriesBar @JvmOverloads constructor( + context: Context, + attrs: AttributeSet? = null, + defStyleAttr: Int = 0 +) : HorizontalScrollView(context, attrs, defStyleAttr) { + + private val row = LinearLayout(context) + + var items: List = emptyList() + set(value) { + field = value + render() + } + + /** Хост кладёт обложку в `ImageView` своим загрузчиком. */ + var imageLoader: ((ImageView, String) -> Unit)? = null + set(value) { + field = value + render() + } + + var onItemClick: ((index: Int, item: PersonalizationStoryItem) -> Unit)? = null + + /** Диаметр обложек в пикселях. */ + var coverSize: Int = (88 * resources.displayMetrics.density).toInt() + set(value) { + field = value + render() + } + + private var skeletonCount = 0 + + init { + isHorizontalScrollBarEnabled = false + clipToPadding = false + val padding = resources.getDimensionPixelSize(R.dimen.personalization_spacing_xl) + setPadding(padding, padding, padding, padding) + row.orientation = LinearLayout.HORIZONTAL + addView(row, LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT)) + } + + /** Скелетон загрузки: [count] пустых превью. Сбрасывается установкой [items]. */ + fun showSkeleton(count: Int = 4) { + skeletonCount = count + row.removeAllViews() + repeat(count) { index -> + row.addView( + PersonalizationStoryPreview(context).apply { + cover.coverSize = coverSize + state = PersonalizationStoryCover.State.SKELETON + }, + itemParams(index) + ) + } + } + + private fun render() { + skeletonCount = 0 + row.removeAllViews() + items.forEachIndexed { index, item -> + val preview = PersonalizationStoryPreview(context).apply { + cover.coverSize = coverSize + title = item.title + state = item.state + cover.segments = item.segments + cover.seenSegments = item.seenSegments + contentDescription = item.title + setOnClickListener { onItemClick?.invoke(index, item) } + } + item.imageUrl?.takeIf { it.isNotEmpty() }?.let { url -> + imageLoader?.invoke(preview.cover.imageView, url) + } + row.addView(preview, itemParams(index)) + } + } + + private fun itemParams(index: Int) = + LinearLayout.LayoutParams(LinearLayout.LayoutParams.WRAP_CONTENT, LinearLayout.LayoutParams.WRAP_CONTENT).apply { + if (index > 0) marginStart = resources.getDimensionPixelSize(R.dimen.personalization_spacing_xl) + } +} diff --git a/personalization-sdk/src/main/kotlin/com/personalization/ui/components/PersonalizationStoryNavigation.kt b/personalization-sdk/src/main/kotlin/com/personalization/ui/components/PersonalizationStoryNavigation.kt new file mode 100644 index 00000000..ebb9b7dc --- /dev/null +++ b/personalization-sdk/src/main/kotlin/com/personalization/ui/components/PersonalizationStoryNavigation.kt @@ -0,0 +1,155 @@ +package com.personalization.ui.components + +import android.content.Context +import android.graphics.Canvas +import android.graphics.Paint +import android.graphics.RectF +import android.util.AttributeSet +import android.view.Gravity +import android.view.View +import android.widget.FrameLayout +import android.widget.LinearLayout +import androidx.appcompat.widget.AppCompatImageView +import androidx.core.widget.ImageViewCompat +import com.personalization.R +import com.personalization.ui.InternalPersonalizationUiApi +import com.personalization.ui.PersonalizationTheme + +/** + * Прогресс слайдов сторис: по полоске на слайд. + * + * Источник: Figma, Navigation/Story (10:863), рамка Progress: полоски высотой 2 + * с шагом 2 и скруглением 1 делят ширину поровну. Пройденное — Text/Secondary, + * дорожка — Line/Generic. Текущая полоска заполнена на [progress]. + */ +@InternalPersonalizationUiApi +class PersonalizationStoryProgress @JvmOverloads constructor( + context: Context, + attrs: AttributeSet? = null, + defStyleAttr: Int = 0 +) : View(context, attrs, defStyleAttr) { + + /** Число слайдов. */ + var count: Int = 1 + set(value) { + field = value.coerceAtLeast(1) + invalidate() + } + + /** Индекс текущего слайда: полоски до него заполнены целиком. */ + var current: Int = 0 + set(value) { + field = value + invalidate() + } + + /** Заполнение текущей полоски, 0…1. */ + var progress: Float = 0f + set(value) { + field = value.coerceIn(0f, 1f) + invalidate() + } + + private val paint = Paint(Paint.ANTI_ALIAS_FLAG) + private val rect = RectF() + + override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) { + setMeasuredDimension( + MeasureSpec.getSize(widthMeasureSpec), + resolveSize(dp(HEIGHT_DP), heightMeasureSpec) + ) + } + + override fun onDraw(canvas: Canvas) { + val gap = dp(GAP_DP).toFloat() + val radius = dp(RADIUS_DP).toFloat() + val segment = (width - gap * (count - 1)) / count + val filled = PersonalizationTheme.color(context, R.color.personalization_text_secondary) + val track = PersonalizationTheme.color(context, R.color.personalization_line_generic) + + for (index in 0 until count) { + val left = index * (segment + gap) + rect.set(left, 0f, left + segment, height.toFloat()) + paint.color = track + canvas.drawRoundRect(rect, radius, radius, paint) + + val fraction = when { + index < current -> 1f + index == current -> progress + else -> 0f + } + if (fraction > 0f) { + rect.set(left, 0f, left + segment * fraction, height.toFloat()) + paint.color = filled + canvas.drawRoundRect(rect, radius, radius, paint) + } + } + } + + private fun dp(value: Int): Int = (value * resources.displayMetrics.density).toInt() + + private companion object { + const val HEIGHT_DP = 2 + const val GAP_DP = 2 + const val RADIUS_DP = 1 + } +} + +/** + * Шапка сторис: прогресс слайдов и крестик. + * + * Источник: Figma, Navigation/Story (10:863): колонка с шагом 12 — прогресс и строка + * высотой 32 с крестиком справа (cross 32, глиф Text/Secondary, прозрачность 65%). + * Аватар и заголовок в символе есть, но во всех экранах сторис скрыты. + */ +@InternalPersonalizationUiApi +class PersonalizationStoryNavigation @JvmOverloads constructor( + context: Context, + attrs: AttributeSet? = null, + defStyleAttr: Int = 0 +) : LinearLayout(context, attrs, defStyleAttr) { + + val progress = PersonalizationStoryProgress(context) + + private val close = AppCompatImageView(context) + + /** Крестик: слайд пропускает к нему касания и при открытой шторке товаров (F2). */ + internal val closeButton: View get() = close + + var onClose: (() -> Unit)? = null + + var closeContentDescription: CharSequence? = "Close" + set(value) { + field = value + close.contentDescription = value + } + + init { + orientation = VERTICAL + addView(progress, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT)) + + val row = FrameLayout(context) + close.setImageResource(R.drawable.personalization_ic_cross) + ImageViewCompat.setImageTintList( + close, + PersonalizationTheme.colorStateList(context, R.color.personalization_text_secondary) + ) + close.alpha = CLOSE_ALPHA + close.contentDescription = closeContentDescription + close.setOnClickListener { onClose?.invoke() } + row.addView(close, FrameLayout.LayoutParams(dp(CLOSE_DP), dp(CLOSE_DP), Gravity.END or Gravity.CENTER_VERTICAL)) + addView( + row, + LayoutParams(LayoutParams.MATCH_PARENT, dp(CLOSE_DP)).apply { + topMargin = resources.getDimensionPixelSize(R.dimen.personalization_spacing_lg) + } + ) + } + + private fun dp(value: Int): Int = (value * resources.displayMetrics.density).toInt() + + private companion object { + const val CLOSE_DP = 32 + const val CLOSE_ALPHA = 0.65f + } +} diff --git a/personalization-sdk/src/main/kotlin/com/personalization/ui/components/PersonalizationStoryPrice.kt b/personalization-sdk/src/main/kotlin/com/personalization/ui/components/PersonalizationStoryPrice.kt new file mode 100644 index 00000000..80517394 --- /dev/null +++ b/personalization-sdk/src/main/kotlin/com/personalization/ui/components/PersonalizationStoryPrice.kt @@ -0,0 +1,285 @@ +package com.personalization.ui.components + +import android.annotation.SuppressLint +import android.content.ClipData +import android.content.ClipboardManager +import android.content.Context +import android.graphics.drawable.GradientDrawable +import android.util.AttributeSet +import android.util.TypedValue +import android.view.Gravity +import android.view.MotionEvent +import android.view.View +import android.widget.FrameLayout +import android.widget.LinearLayout +import androidx.appcompat.widget.AppCompatImageView +import androidx.appcompat.widget.AppCompatTextView +import androidx.core.widget.ImageViewCompat +import androidx.core.widget.TextViewCompat +import com.personalization.R +import com.personalization.ui.InternalPersonalizationUiApi +import com.personalization.ui.PersonalizationTheme + +/** + * Плашка цены товара в сторис. + * + * Источник: Figma, Card/Story/Price (10:875): скругление 12, заливка #F2F2F2 95% + * (в макете сырой цвет, одинаковый в обеих темах — поэтому текст всегда Text/Dark). + * Слева колонка с отступами 12/16: старая цена (SemiBold 14, зачёркнута, группа + * прозрачна на 50%) и цена (SemiBold 24); валюта у обеих — Regular 14. + * + * Справа, по [type]: + * - [Type.DISCOUNT] — блок Brand/Primary со скидкой SemiBold 36 (`10%`); + * - [Type.PROMO_CODE] — чёрный блок с подписью «Promo code» и кодом SemiBold 24, + * иконка copy в углу. Нажатие копирует код в буфер, показывает тост [copiedText] + * (в задаче на странице Stories: «по умолчанию Copied») и зовёт [onPromoCopied]; + * блок при нажатии чуть увеличивается — кадр Tap Zoom Effect. + */ +@InternalPersonalizationUiApi +class PersonalizationStoryPrice @JvmOverloads constructor( + context: Context, + attrs: AttributeSet? = null, + defStyleAttr: Int = 0 +) : LinearLayout(context, attrs, defStyleAttr) { + + enum class Type { PRICE, DISCOUNT, PROMO_CODE } + + var type: Type = Type.PRICE + set(value) { + field = value + render() + } + + /** Цена в формате сервера — `"1 190 900 ₽"`; валюта отделяется сама. */ + var price: CharSequence? = null + set(value) { + field = value + render() + } + + /** Старая цена; `null` — строки нет. */ + var oldPrice: CharSequence? = null + set(value) { + field = value + render() + } + + /** Текст скидки для [Type.DISCOUNT] — `"10%"`. */ + var discount: CharSequence? = null + set(value) { + field = value + render() + } + + /** Промокод для [Type.PROMO_CODE]. */ + var promoCode: String? = null + set(value) { + field = value + render() + } + + var promoCaption: CharSequence = "Promo code" + set(value) { + field = value + render() + } + + /** Текст тоста после копирования. */ + var copiedText: CharSequence = "Copied" + + /** Где показывать тост: в макете два варианта — над плашкой и сверху экрана. */ + var toastPosition: PersonalizationToast.Position = PersonalizationToast.Position.TOP + + /** Код скопирован в буфер. */ + var onPromoCopied: ((String) -> Unit)? = null + + private val priceColumn = LinearLayout(context) + private val oldPriceView = AppCompatTextView(context) + private val priceView = AppCompatTextView(context) + private val discountView = AppCompatTextView(context) + private val promoBox = FrameLayout(context) + private val promoColumn = LinearLayout(context) + private val promoCaptionView = AppCompatTextView(context) + private val promoCodeView = AppCompatTextView(context) + private val copyIcon = AppCompatImageView(context) + + private val radius = dp(RADIUS_DP).toFloat() + private val measurePaint = android.text.TextPaint(android.graphics.Paint.ANTI_ALIAS_FLAG) + + init { + orientation = HORIZONTAL + background = GradientDrawable().apply { + cornerRadius = radius + setColor(BOX_COLOR) + } + + priceColumn.orientation = VERTICAL + priceColumn.gravity = Gravity.CENTER_VERTICAL + priceColumn.setPadding(dp(16), dp(12), dp(16), dp(12)) + oldPriceView.style(sizeSp = 14f, emphasized = true, colorRes = R.color.personalization_text_dark_secondary) + oldPriceView.alpha = OLD_PRICE_ALPHA + priceView.style(sizeSp = 24f, emphasized = true, colorRes = R.color.personalization_text_dark_primary) + priceColumn.addView(oldPriceView, LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT)) + priceColumn.addView(priceView, LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT)) + + discountView.style(sizeSp = 36f, emphasized = true, colorRes = R.color.personalization_text_light_primary) + discountView.gravity = Gravity.CENTER + discountView.setPadding(dp(16), 0, dp(16), 0) + discountView.background = endRounded(PersonalizationTheme.color(context, R.color.personalization_brand_primary)) + + promoColumn.apply { + orientation = VERTICAL + gravity = Gravity.CENTER + setPadding(dp(16), dp(12), dp(16), dp(12)) + } + promoCaptionView.style(sizeSp = 14f, emphasized = true, colorRes = R.color.personalization_text_light_secondary) + promoCaptionView.gravity = Gravity.CENTER + promoCodeView.style(sizeSp = 24f, emphasized = true, colorRes = R.color.personalization_text_light_primary) + promoCodeView.gravity = Gravity.CENTER + promoCodeView.maxLines = 1 + // Длинный код ужимается, а не режется: его надо прочитать целиком. + TextViewCompat.setAutoSizeTextTypeUniformWithConfiguration( + promoCodeView, 14, 24, 1, TypedValue.COMPLEX_UNIT_SP + ) + promoColumn.addView(promoCaptionView, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT)) + promoColumn.addView(promoCodeView, LayoutParams(LayoutParams.MATCH_PARENT, dp(PROMO_CODE_HEIGHT_DP))) + promoBox.addView( + promoColumn, + FrameLayout.LayoutParams(FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.WRAP_CONTENT, Gravity.CENTER) + ) + copyIcon.setImageResource(R.drawable.personalization_ic_copy) + ImageViewCompat.setImageTintList( + copyIcon, + PersonalizationTheme.colorStateList(context, R.color.personalization_text_light_hint) + ) + promoBox.addView( + copyIcon, + FrameLayout.LayoutParams(dp(COPY_DP), dp(COPY_DP), Gravity.TOP or Gravity.END).apply { + topMargin = dp(4) + marginEnd = dp(4) + } + ) + promoBox.background = endRounded(PersonalizationTheme.color(context, R.color.personalization_text_dark_primary)) + promoBox.isClickable = true + promoBox.contentDescription = promoCaption + setupPromoPress() + + addView(priceColumn, LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT)) + addView(discountView, LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.MATCH_PARENT)) + addView(promoBox, LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.MATCH_PARENT)) + render() + } + + override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) { + // Промокод делит ширину поровну с ценой, но длинный код берёт сколько нужно — + // не больше [MAX_PROMO_SHARE] ряда, дальше код ужимается автоподбором кегля. + if (promoBox.visibility == View.VISIBLE && MeasureSpec.getMode(widthMeasureSpec) != MeasureSpec.UNSPECIFIED) { + val total = MeasureSpec.getSize(widthMeasureSpec) + measurePaint.typeface = promoCodeView.typeface + measurePaint.textSize = spPx(24f).toFloat() + val needed = measurePaint.measureText(promoCode.orEmpty()) + dp(16) * 2 + val width = needed.toInt().coerceIn(total / 2, (total * MAX_PROMO_SHARE).toInt()) + val params = promoBox.layoutParams as LayoutParams + if (params.width != width) params.width = width + } + // Чёрный блок тянется по высоте ряда, а ряд меряется по колонке цены: без старой цены + // она ниже подписи с кодом, и те обрезались. Колонка цены не ниже промокода. + priceColumn.minimumHeight = if (promoBox.visibility == View.VISIBLE) promoHeight() else 0 + super.onMeasure(widthMeasureSpec, heightMeasureSpec) + } + + private fun promoHeight(): Int { + val width = (promoBox.layoutParams as LayoutParams).width + val widthSpec = if (width > 0) { + MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY) + } else { + MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED) + } + promoColumn.measure(widthSpec, MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED)) + return promoColumn.measuredHeight + } + + private fun render() { + val currencyPx = spPx(14f) + val old = oldPrice?.takeIf { it.isNotEmpty() } + oldPriceView.visibility = if (old != null) View.VISIBLE else View.GONE + oldPriceView.text = old?.let { + PersonalizationStoryAmount.parse(it).toSpannable(currencyPx, strikethrough = true) + } + priceView.text = price?.let { PersonalizationStoryAmount.parse(it).toSpannable(currencyPx) } + + val showDiscount = type == Type.DISCOUNT && !discount.isNullOrEmpty() + val showPromo = type == Type.PROMO_CODE && !promoCode.isNullOrEmpty() + discountView.visibility = if (showDiscount) View.VISIBLE else View.GONE + discountView.text = discount + promoBox.visibility = if (showPromo) View.VISIBLE else View.GONE + promoCaptionView.text = promoCaption + promoCodeView.text = promoCode + promoBox.contentDescription = promoCaption + + // Колонка цены тянется, когда справа скидка; с промокодом делит ряд поровну. + (priceColumn.layoutParams as LayoutParams).apply { + width = if (showDiscount || showPromo) 0 else LayoutParams.WRAP_CONTENT + weight = if (showDiscount || showPromo) 1f else 0f + } + (promoBox.layoutParams as LayoutParams).weight = 0f + requestLayout() + } + + @SuppressLint("ClickableViewAccessibility") + private fun setupPromoPress() { + promoBox.setOnTouchListener { view, event -> + when (event.actionMasked) { + MotionEvent.ACTION_DOWN -> + view.animate().scaleX(PRESS_SCALE).scaleY(PRESS_SCALE).setDuration(PRESS_MS).start() + MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> + view.animate().scaleX(1f).scaleY(1f).setDuration(PRESS_MS).start() + } + false + } + promoBox.setOnClickListener { copyPromo() } + } + + private fun copyPromo() { + val code = promoCode?.takeIf { it.isNotEmpty() } ?: return + val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as? ClipboardManager + clipboard?.setPrimaryClip(ClipData.newPlainText(promoCaption, code)) + PersonalizationToast.show(this, copiedText, toastPosition) + onPromoCopied?.invoke(code) + } + + /** Правый блок повторяет скругление плашки только справа. */ + private fun endRounded(color: Int) = GradientDrawable().apply { + setColor(color) + val rtl = layoutDirection == View.LAYOUT_DIRECTION_RTL + cornerRadii = if (rtl) { + floatArrayOf(radius, radius, 0f, 0f, 0f, 0f, radius, radius) + } else { + floatArrayOf(0f, 0f, radius, radius, radius, radius, 0f, 0f) + } + } + + private fun AppCompatTextView.style(sizeSp: Float, emphasized: Boolean, colorRes: Int) { + includeFontPadding = false + typeface = PersonalizationTheme.typeface(context, emphasized) + setTextSize(TypedValue.COMPLEX_UNIT_SP, sizeSp) + setTextColor(PersonalizationTheme.color(context, colorRes)) + } + + private fun dp(value: Int): Int = (value * resources.displayMetrics.density).toInt() + + private fun spPx(sp: Float): Int = + TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP, sp, resources.displayMetrics).toInt() + + private companion object { + /** #F2F2F2 с прозрачностью 95% — как в макете, без переменной. */ + const val BOX_COLOR = 0xF2F2F2F2.toInt() + const val RADIUS_DP = 12 + const val OLD_PRICE_ALPHA = 0.5f + const val COPY_DP = 24 + const val PROMO_CODE_HEIGHT_DP = 29 + const val MAX_PROMO_SHARE = 0.65f + const val PRESS_SCALE = 1.03f + const val PRESS_MS = 120L + } +} diff --git a/personalization-sdk/src/main/kotlin/com/personalization/ui/components/PersonalizationStorySupport.kt b/personalization-sdk/src/main/kotlin/com/personalization/ui/components/PersonalizationStorySupport.kt new file mode 100644 index 00000000..06379633 --- /dev/null +++ b/personalization-sdk/src/main/kotlin/com/personalization/ui/components/PersonalizationStorySupport.kt @@ -0,0 +1,168 @@ +package com.personalization.ui.components + +import android.content.Context +import android.content.res.Configuration +import android.graphics.Canvas +import android.graphics.Color +import android.graphics.LinearGradient +import android.graphics.Path +import android.graphics.Shader +import android.graphics.Typeface +import android.text.TextPaint +import android.text.style.MetricAffectingSpan +import android.graphics.drawable.GradientDrawable +import android.text.SpannableStringBuilder +import android.text.Spanned +import android.text.style.AbsoluteSizeSpan +import android.text.style.ForegroundColorSpan +import android.text.style.StrikethroughSpan +import android.util.AttributeSet +import androidx.appcompat.view.ContextThemeWrapper +import androidx.appcompat.widget.AppCompatImageView +import com.personalization.R +import com.personalization.ui.InternalPersonalizationUiApi +import com.personalization.ui.PersonalizationTheme + +/** + * Общие куски сторис: разбор цены на сумму и валюту, скелетон, круглая картинка, + * принудительно тёмный контекст для медиа-слайдов. + */ +internal object StorySupport { + + /** + * Скелетон в макете — градиент чёрного 5% → 30% → 5%. Цвет берётся из Text/Primary, + * чтобы в тёмной теме полоса была белой: чёрная на тёмном фоне не видна. + */ + fun skeletonColors(context: Context): IntArray { + val base = PersonalizationTheme.color(context, R.color.personalization_text_primary) + fun alpha(value: Int) = Color.argb(value, Color.red(base), Color.green(base), Color.blue(base)) + return intArrayOf(alpha(13), alpha(77), alpha(13)) + } + + fun skeletonShader(context: Context, width: Float, height: Float): Shader = + LinearGradient(0f, 0f, width, height, skeletonColors(context), null, Shader.TileMode.CLAMP) + + fun skeletonDrawable(context: Context, shape: Int, radius: Float = 0f): GradientDrawable = + GradientDrawable(GradientDrawable.Orientation.TL_BR, skeletonColors(context)).apply { + this.shape = shape + if (shape == GradientDrawable.RECTANGLE) cornerRadius = radius + } + + /** + * Контекст с тёмными токенами для поддерева: медиа-слайды сторис в макете + * всегда в режиме Dark — белые прогресс, крестик и текст, тёмная шторка товаров. + * + * Тема хоста сохраняется (брендовые цвета остаются), а ресурсы берутся из + * `values-night`: [PersonalizationTheme] резолвит атрибут в id ресурса и читает + * значение уже через ресурсы этого контекста. + */ + fun darkContext(base: Context): Context { + val configuration = Configuration(base.resources.configuration).apply { + uiMode = (uiMode and Configuration.UI_MODE_NIGHT_MASK.inv()) or + Configuration.UI_MODE_NIGHT_YES + } + return ContextThemeWrapper(base, base.theme).apply { + applyOverrideConfiguration(configuration) + } + } +} + +/** + * Цена, как её отдаёт сервер (`"1 190 900 ₽"`), разбитая на сумму и валюту: + * в макете валюта набрана мельче и обычным начертанием. + */ +@InternalPersonalizationUiApi +data class PersonalizationStoryAmount(val amount: String, val currency: String?) { + + companion object { + /** + * Валюта — последний токен через пробел, если в нём нет цифр + * (`"19 990 ₽"` → `19 990` + `₽`). Иначе строка остаётся целиком. + */ + fun parse(formatted: CharSequence): PersonalizationStoryAmount { + val text = formatted.toString().trim() + val space = text.lastIndexOf(' ') + if (space <= 0) return PersonalizationStoryAmount(text, null) + val tail = text.substring(space + 1) + if (tail.isEmpty() || tail.any { it.isDigit() }) return PersonalizationStoryAmount(text, null) + return PersonalizationStoryAmount(text.substring(0, space).trimEnd(), tail) + } + } + + /** + * Сумма крупным кеглем, валюта — [currencySizePx] после пробела. Пробел тоже + * мелкий: в макете между ними 4. + */ + fun toSpannable( + currencySizePx: Int, + currencyColor: Int? = null, + strikethrough: Boolean = false + ): CharSequence { + val builder = SpannableStringBuilder(amount) + if (strikethrough) { + builder.setSpan(StrikethroughSpan(), 0, amount.length, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE) + } + if (currency != null) { + val start = builder.length + builder.append(' ').append(currency) + builder.setSpan( + AbsoluteSizeSpan(currencySizePx), + start, + builder.length, + Spanned.SPAN_EXCLUSIVE_EXCLUSIVE + ) + if (currencyColor != null) { + builder.setSpan( + ForegroundColorSpan(currencyColor), + start, + builder.length, + Spanned.SPAN_EXCLUSIVE_EXCLUSIVE + ) + } + } + return builder + } +} + +/** + * Картинка, обрезанная кругом. `clipToOutline` есть только с API 21, а SDK держит + * minSdk 19 — поэтому клип по пути, он работает везде. + */ +internal class StoryCircleImageView @JvmOverloads constructor( + context: Context, + attrs: AttributeSet? = null +) : AppCompatImageView(context, attrs) { + + private val clip = Path() + + init { + scaleType = ScaleType.CENTER_CROP + } + + override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) { + super.onSizeChanged(w, h, oldw, oldh) + clip.reset() + clip.addCircle(w / 2f, h / 2f, minOf(w, h) / 2f, Path.Direction.CW) + } + + override fun onDraw(canvas: Canvas) { + val save = canvas.save() + canvas.clipPath(clip) + super.onDraw(canvas) + canvas.restoreToCount(save) + } +} + +/** + * Начертание для части строки. `TypefaceSpan(Typeface)` есть только с API 28, + * а число и единица таймера набраны разными начертаниями в одной строке. + */ +internal class StoryTypefaceSpan(private val typeface: Typeface) : MetricAffectingSpan() { + override fun updateDrawState(paint: TextPaint) { + paint.typeface = typeface + } + + override fun updateMeasureState(paint: TextPaint) { + paint.typeface = typeface + } +} diff --git a/personalization-sdk/src/main/kotlin/com/personalization/ui/components/PersonalizationStoryTextBlock.kt b/personalization-sdk/src/main/kotlin/com/personalization/ui/components/PersonalizationStoryTextBlock.kt new file mode 100644 index 00000000..dcf2a000 --- /dev/null +++ b/personalization-sdk/src/main/kotlin/com/personalization/ui/components/PersonalizationStoryTextBlock.kt @@ -0,0 +1,186 @@ +package com.personalization.ui.components + +import android.content.Context +import android.graphics.Typeface +import android.graphics.drawable.GradientDrawable +import android.util.AttributeSet +import android.util.TypedValue +import android.view.Gravity +import androidx.annotation.ColorInt +import androidx.appcompat.widget.AppCompatTextView +import androidx.core.widget.TextViewCompat +import com.personalization.R +import com.personalization.ui.InternalPersonalizationUiApi +import com.personalization.ui.PersonalizationTheme + +/** + * Текстовый блок слайда. + * + * Источник: Figma, Text block (370:16189) и задача «Текстовый блок» на странице Stories: + * блок с фоном ([blockColor] не `null`) — скругление 12 и отступы по горизонтали 16, + * по вертикали 12 у крупного текста и 8 у остальных; блок без фона — без отступов. + * Размеры из макета — [Size]: 48/48, 30/36, 20/24, Regular. Текст по умолчанию — + * Text/Light Primary на фоне и Text/Primary без него. + * + * Кегль, цвет, выравнивание и начертание сторис задаёт админка — всё это свойства, + * пресеты [Size] только стартовые значения. Без своего интерлиньяжа ([lineHeightSp] = `null`) + * берётся высота строки ближайшего по кеглю пресета. + */ +@InternalPersonalizationUiApi +class PersonalizationStoryTextBlock @JvmOverloads constructor( + context: Context, + attrs: AttributeSet? = null, + defStyleAttr: Int = 0 +) : AppCompatTextView(context, attrs, defStyleAttr) { + + enum class Size(val textSp: Float, val lineHeightSp: Float) { + LARGE(48f, 48f), + MEDIUM(30f, 36f), + SMALL(20f, 24f); + + internal companion object { + /** Пресет, ближайший к кеглю [textSp]. */ + fun nearest(textSp: Float): Size = values().minByOrNull { kotlin.math.abs(it.textSp - textSp) } ?: SMALL + + /** + * Высота строки пресета, пересчитанная на кегль и округлённая (F4): 48/48 → 1.0, + * 30/36 и 20/24 → 1.2. Ничья между пресетами — у крупного. + */ + fun lineHeightFor(textSp: Float): Float = + nearest(textSp).let { Math.round(textSp * it.lineHeightSp / it.textSp).toFloat() } + } + } + + enum class Align { START, CENTER, END } + + /** Пресет кегля и интерлиньяжа. */ + var size: Size = Size.SMALL + set(value) { + field = value + textSizeSp = value.textSp + lineHeightSp = value.lineHeightSp + } + + var textSizeSp: Float = Size.SMALL.textSp + set(value) { + field = value + applyStyle() + } + + /** Интерлиньяж; `null` — высота строки пресета для этого кегля. */ + var lineHeightSp: Float? = Size.SMALL.lineHeightSp + set(value) { + field = value + applyStyle() + } + + /** Цвет подложки; `null` — блок без фона. */ + @ColorInt + var blockColor: Int? = null + set(value) { + field = value + applyStyle() + } + + /** Цвет текста; `null` — токен по виду блока. */ + @ColorInt + var textColorOverride: Int? = null + set(value) { + field = value + applyStyle() + } + + var align: Align = Align.START + set(value) { + field = value + applyStyle() + } + + var bold: Boolean = false + set(value) { + field = value + applyStyle() + } + + var italic: Boolean = false + set(value) { + field = value + applyStyle() + } + + /** Семейство от админки (`serif`, `monospaced`); `null` — шрифт кита. */ + var fontFamily: String? = null + set(value) { + field = value + applyStyle() + } + + init { + includeFontPadding = false + applyStyle() + } + + /** Отступы блока с фоном: по вертикали 12 у текста крупнее Medium, 8 у остального. */ + internal fun solidPadding(): Pair { + val vertical = if (textSizeSp > MEDIUM_TEXT_SP) 12 else 8 + return dp(16) to dp(vertical) + } + + private fun applyStyle() { + setTextSize(TypedValue.COMPLEX_UNIT_SP, textSizeSp) + // Без своего интерлиньяжа — пресет для кегля: иначе осталась бы высота прошлого кегля. + TextViewCompat.setLineHeight(this, spPx(lineHeightSp ?: Size.lineHeightFor(textSizeSp))) + val base = when (fontFamily) { + "serif" -> Typeface.SERIF + "monospaced", "monospace" -> Typeface.MONOSPACE + else -> PersonalizationTheme.typeface(context, emphasized = false) + } + val style = when { + bold && italic -> Typeface.BOLD_ITALIC + bold -> Typeface.BOLD + italic -> Typeface.ITALIC + else -> Typeface.NORMAL + } + setTypeface(base, style) + gravity = Gravity.CENTER_VERTICAL or when (align) { + Align.START -> Gravity.START + Align.CENTER -> Gravity.CENTER_HORIZONTAL + Align.END -> Gravity.END + } + textAlignment = when (align) { + Align.START -> TEXT_ALIGNMENT_VIEW_START + Align.CENTER -> TEXT_ALIGNMENT_CENTER + Align.END -> TEXT_ALIGNMENT_VIEW_END + } + + val solid = blockColor + if (solid != null) { + val (horizontal, vertical) = solidPadding() + setPadding(horizontal, vertical, horizontal, vertical) + background = GradientDrawable().apply { + cornerRadius = dp(12).toFloat() + setColor(solid) + } + } else { + setPadding(0, 0, 0, 0) + background = null + } + setTextColor( + textColorOverride ?: PersonalizationTheme.color( + context, + if (solid != null) R.color.personalization_text_light_primary + else R.color.personalization_text_primary + ) + ) + } + + private fun dp(value: Int): Int = (value * resources.displayMetrics.density).toInt() + + private fun spPx(sp: Float): Int = + TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP, sp, resources.displayMetrics).toInt() + + private companion object { + /** Кегль Medium (30): всё крупнее получает отступы Large. */ + const val MEDIUM_TEXT_SP = 30f + } +} diff --git a/personalization-sdk/src/main/kotlin/com/personalization/ui/components/PersonalizationStoryTimer.kt b/personalization-sdk/src/main/kotlin/com/personalization/ui/components/PersonalizationStoryTimer.kt new file mode 100644 index 00000000..1a78357a --- /dev/null +++ b/personalization-sdk/src/main/kotlin/com/personalization/ui/components/PersonalizationStoryTimer.kt @@ -0,0 +1,187 @@ +package com.personalization.ui.components + +import android.content.Context +import android.graphics.drawable.GradientDrawable +import android.text.SpannableStringBuilder +import android.text.Spanned +import android.text.style.AbsoluteSizeSpan +import android.text.style.ForegroundColorSpan +import android.util.AttributeSet +import android.util.TypedValue +import android.view.Gravity +import android.widget.LinearLayout +import androidx.appcompat.widget.AppCompatTextView +import com.personalization.R +import com.personalization.ui.InternalPersonalizationUiApi +import com.personalization.ui.PersonalizationTheme + +/** + * Обратный отсчёт акции в сторис. + * + * Источник: Figma, Card/Story/Timer (345:14226), два вида: + * - [Style.MERGED] — одна плашка со скруглением 12, отступами 8/12 и шагом 12; + * - [Style.SEPARATE] — четыре плашки со скруглением 8 и шагом 8, делят ширину поровну. + * Заливка Neutral/Neutral 100. Число — SemiBold 36 Text/Primary, единица — Regular 20 + * Text/Secondary через 2, по базовой линии. + * + * В ответе сторис таймера нет — компонент для хоста: он задаёт [endTimeMillis]. + */ +@InternalPersonalizationUiApi +class PersonalizationStoryTimer @JvmOverloads constructor( + context: Context, + attrs: AttributeSet? = null, + defStyleAttr: Int = 0 +) : LinearLayout(context, attrs, defStyleAttr) { + + enum class Style { MERGED, SEPARATE } + + var style: Style = Style.MERGED + set(value) { + field = value + build() + } + + /** Момент окончания, `System.currentTimeMillis()`-время. */ + var endTimeMillis: Long = 0L + set(value) { + field = value + tick() + } + + /** Подписи дней, часов, минут и секунд. */ + var labels: List = listOf("d", "h", "m", "s") + set(value) { + require(value.size == UNITS) { "Timer needs $UNITS labels: days, hours, minutes, seconds" } + field = value + render() + } + + /** Отсчёт дошёл до нуля. */ + var onFinished: (() -> Unit)? = null + + /** Источник времени — подменяется в тестах. */ + internal var clock: () -> Long = System::currentTimeMillis + + private val units = List(UNITS) { AppCompatTextView(context) } + private var parts = PersonalizationStoryTimerParts(0, 0, 0, 0) + private var finished = false + private val ticker = Runnable { tick() } + + init { + orientation = HORIZONTAL + gravity = Gravity.CENTER + units.forEach { unit -> + unit.includeFontPadding = false + unit.gravity = Gravity.CENTER + unit.maxLines = 1 + } + build() + } + + override fun onAttachedToWindow() { + super.onAttachedToWindow() + tick() + } + + override fun onDetachedFromWindow() { + removeCallbacks(ticker) + super.onDetachedFromWindow() + } + + private fun build() { + removeAllViews() + val merged = style == Style.MERGED + background = if (merged) box(dp(12).toFloat()) else null + if (merged) setPadding(dp(12), dp(8), dp(12), dp(8)) else setPadding(0, 0, 0, 0) + units.forEachIndexed { index, unit -> + unit.background = if (merged) null else box(dp(8).toFloat()) + if (merged) unit.setPadding(0, 0, 0, 0) else unit.setPadding(dp(12), dp(8), dp(12), dp(8)) + val params = if (merged) { + LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT) + } else { + LayoutParams(0, LayoutParams.WRAP_CONTENT, 1f) + } + if (index > 0) params.marginStart = dp(if (merged) 12 else 8) + addView(unit, params) + } + render() + } + + private fun tick() { + removeCallbacks(ticker) + val remaining = endTimeMillis - clock() + parts = PersonalizationStoryTimerParts.of(remaining) + render() + if (remaining > 0) { + finished = false + // До следующей целой секунды, чтобы цифры не отставали. + val delay = (remaining % SECOND).takeIf { it > 0 } ?: SECOND + if (isAttachedToWindow) postDelayed(ticker, delay) + } else if (!finished && endTimeMillis > 0) { + finished = true + onFinished?.invoke() + } + } + + private fun render() { + val values = listOf(parts.days, parts.hours, parts.minutes, parts.seconds) + val numberColor = PersonalizationTheme.color(context, R.color.personalization_text_primary) + val labelColor = PersonalizationTheme.color(context, R.color.personalization_text_secondary) + val numberSize = spPx(36f) + val labelSize = spPx(20f) + units.forEachIndexed { index, unit -> + // Дни как есть, часы, минуты и секунды — всегда две цифры: ширина не прыгает. + val number = if (index == 0) values[index].toString() else values[index].toString().padStart(2, '0') + val text = SpannableStringBuilder(number) + text.setSpan(AbsoluteSizeSpan(numberSize), 0, number.length, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE) + text.setSpan(ForegroundColorSpan(numberColor), 0, number.length, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE) + PersonalizationTheme.typeface(context, emphasized = true)?.let { + text.setSpan(StoryTypefaceSpan(it), 0, number.length, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE) + } + val start = text.length + // Зазор 2 между числом и единицей — узкий пробел мелким кеглем. + text.append(' ').append(labels[index]) + text.setSpan(AbsoluteSizeSpan(labelSize), start, text.length, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE) + text.setSpan(ForegroundColorSpan(labelColor), start, text.length, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE) + unit.typeface = PersonalizationTheme.typeface(context, emphasized = false) + unit.text = text + } + } + + private fun box(radius: Float) = GradientDrawable().apply { + cornerRadius = radius + setColor(PersonalizationTheme.color(context, R.color.personalization_neutral_100)) + } + + private fun dp(value: Int): Int = (value * resources.displayMetrics.density).toInt() + + private fun spPx(sp: Float): Int = + TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP, sp, resources.displayMetrics).toInt() + + private companion object { + const val UNITS = 4 + const val SECOND = 1000L + } +} + +/** Остаток времени по единицам таймера. Отрицательный остаток — нули. */ +@InternalPersonalizationUiApi +data class PersonalizationStoryTimerParts( + val days: Long, + val hours: Long, + val minutes: Long, + val seconds: Long +) { + companion object { + fun of(remainingMillis: Long): PersonalizationStoryTimerParts { + // Округление вверх: пока идёт последняя секунда, на экране 1, а не 0. + val total = if (remainingMillis <= 0) 0L else (remainingMillis + 999) / 1000 + return PersonalizationStoryTimerParts( + days = total / 86_400, + hours = total % 86_400 / 3_600, + minutes = total % 3_600 / 60, + seconds = total % 60 + ) + } + } +} diff --git a/personalization-sdk/src/main/kotlin/com/personalization/ui/components/PersonalizationStoryUsedProducts.kt b/personalization-sdk/src/main/kotlin/com/personalization/ui/components/PersonalizationStoryUsedProducts.kt new file mode 100644 index 00000000..8f06c477 --- /dev/null +++ b/personalization-sdk/src/main/kotlin/com/personalization/ui/components/PersonalizationStoryUsedProducts.kt @@ -0,0 +1,159 @@ +package com.personalization.ui.components + +import android.content.Context +import android.util.AttributeSet +import android.view.Gravity +import android.view.View +import android.widget.FrameLayout +import android.widget.ImageView +import android.widget.LinearLayout +import androidx.appcompat.widget.AppCompatImageView +import androidx.core.widget.ImageViewCompat +import com.personalization.R +import com.personalization.ui.InternalPersonalizationUiApi +import com.personalization.ui.PersonalizationTheme + +/** + * Низ слайда с товарами из кадра: кнопка «Используемые товары» и шторка с каруселью. + * + * Источник: Figma, Card/Used Products (238:7108) и Button/Used Products (345:14578). + * Свёрнуто — строка высотой 64 с отступами 16: по центру кнопка SM Secondary со + * скруглением Rounded и стрелкой вверх ([showText]). Развёрнуто — подложка + * Background/Card: карусель карточек (отступы 16/0/16/16, шаг 16) и та же строка + * с кнопкой [hideText] и стрелкой вниз. + * + * В начале строки — кнопка звука видео-слайда ([showSoundButton], [muted]): + * в макете она живёт здесь же. + */ +@InternalPersonalizationUiApi +class PersonalizationStoryUsedProducts @JvmOverloads constructor( + context: Context, + attrs: AttributeSet? = null, + defStyleAttr: Int = 0 +) : LinearLayout(context, attrs, defStyleAttr) { + + val carousel = PersonalizationProductsCarousel(context) + + private val row = FrameLayout(context) + private val toggle = PersonalizationButton(context) + private val sound = AppCompatImageView(context) + + var products: List + get() = carousel.products + set(value) { + carousel.products = value + applyState() + } + + var imageLoader: ((ImageView, PersonalizationProduct) -> Unit)? + get() = carousel.imageLoader + set(value) { + carousel.imageLoader = value + } + + var onProductClick: ((PersonalizationProduct) -> Unit)? + get() = carousel.onProductClick + set(value) { + carousel.onProductClick = value + } + + var showText: CharSequence = "Used products" + set(value) { + field = value + applyState() + } + + var hideText: CharSequence = "Hide products" + set(value) { + field = value + applyState() + } + + var expanded: Boolean = false + set(value) { + if (field == value) return + field = value + applyState() + onExpandedChange?.invoke(value) + } + + var onExpandedChange: ((Boolean) -> Unit)? = null + + var showSoundButton: Boolean = false + set(value) { + field = value + applyState() + } + + var muted: Boolean = false + set(value) { + field = value + applyState() + } + + var onSoundClick: (() -> Unit)? = null + + /** Описание кнопки звука для TalkBack: звук включён — [soundOnDescription], выключен — [soundOffDescription]. */ + var soundOnDescription: CharSequence = "Sound on" + var soundOffDescription: CharSequence = "Sound off" + + init { + orientation = VERTICAL + + carousel.setPadding(dp(16), dp(16), 0, dp(16)) + carousel.clipToPadding = false + addView(carousel, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT)) + + toggle.size = PersonalizationButton.Size.SM + toggle.buttonView = PersonalizationButton.ButtonView.SECONDARY + toggle.rounded = true + toggle.setOnClickListener { expanded = !expanded } + row.addView( + toggle, + FrameLayout.LayoutParams(FrameLayout.LayoutParams.WRAP_CONTENT, FrameLayout.LayoutParams.WRAP_CONTENT, Gravity.CENTER) + ) + + ImageViewCompat.setImageTintList( + sound, + PersonalizationTheme.colorStateList(context, R.color.personalization_text_secondary) + ) + sound.setOnClickListener { onSoundClick?.invoke() } + row.addView( + sound, + FrameLayout.LayoutParams(dp(SOUND_DP), dp(SOUND_DP), Gravity.START or Gravity.CENTER_VERTICAL) + ) + row.setPadding(dp(16), dp(16), dp(16), dp(16)) + addView(row, LayoutParams(LayoutParams.MATCH_PARENT, dp(ROW_DP))) + + applyState() + } + + private fun applyState() { + val hasProducts = carousel.products.isNotEmpty() + val open = expanded && hasProducts + carousel.visibility = if (open) View.VISIBLE else View.GONE + setBackgroundColor( + if (open) PersonalizationTheme.color(context, R.color.personalization_background_card) else 0 + ) + + toggle.visibility = if (hasProducts) View.VISIBLE else View.GONE + toggle.text = if (open) hideText else showText + toggle.iconEnd = if (open) R.drawable.personalization_ic_angle_down else R.drawable.personalization_ic_angle_up + + sound.visibility = if (showSoundButton) View.VISIBLE else View.GONE + sound.setImageResource(if (muted) R.drawable.personalization_ic_speaker_off else R.drawable.personalization_ic_speaker) + // В макете выключенный звук — иконка на 65%, включённый — непрозрачная. + sound.alpha = if (muted) MUTED_ALPHA else 1f + sound.contentDescription = if (muted) soundOffDescription else soundOnDescription + // Состояние переключателя для TalkBack: звук включён — кнопка выбрана (F1). + sound.isSelected = !muted + } + + private fun dp(value: Int): Int = (value * resources.displayMetrics.density).toInt() + + private companion object { + const val ROW_DP = 64 + const val SOUND_DP = 32 + const val MUTED_ALPHA = 0.65f + } +} diff --git a/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/PersonalizationStories.kt b/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/PersonalizationStories.kt new file mode 100644 index 00000000..0df7dc9a --- /dev/null +++ b/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/PersonalizationStories.kt @@ -0,0 +1,342 @@ +package com.personalization.ui.widgets + +import android.content.Context +import android.util.AttributeSet +import android.view.View +import android.widget.FrameLayout +import android.widget.ImageView +import com.personalization.Cancellable + +import com.personalization.R +import com.personalization.Rees46 +import com.personalization.SDK +import com.personalization.stories.models.Story +import com.personalization.ui.InternalPersonalizationUiApi +import com.personalization.ui.components.PersonalizationStoriesBar + +/** + * Сторис (V2) с данными SDK: лента обложек и полноэкранный просмотр на компонентах кита. + * + * Паттерн Stories из Figma (страница 1:32): «сторис-бар + фулскрин-вьюер, источник — + * сторис-блок по code». Блок грузится тем же запросом, что у старого `StoriesView` + * (`stories/{code}`), — старый виджет остаётся как есть. + * + * Инстанс SDK: [shopId] (атрибут `app:shop_id`) выбирает магазин при нескольких + * зарегистрированных; без него берётся единственный. Резолв — при показе через + * [Rees46.awaitInstance]; явный инстанс можно передать в [attach]. + * + * Пока блок грузится — скелетон. Пустой блок, ошибка загрузки, пустой [code], + * неоднозначный магазин или 15 с без ответа прячут виджет и зовут [onError]. + * Управление из кода — [open], [openStory], [pause], [resume]; без ленты — [show]. + */ +@InternalPersonalizationUiApi +class PersonalizationStories @JvmOverloads constructor( + context: Context, + attrs: AttributeSet? = null, + defStyleAttr: Int = 0 +) : FrameLayout(context, attrs, defStyleAttr) { + + /** Лента — доступна для тонкой настройки (размер обложек, отступы). */ + val bar = PersonalizationStoriesBar(context) + + /** Код сторис-блока. Менять до показа или вызвать [reload]. */ + var code: String? = null + + /** Магазин; `null` — единственный зарегистрированный. Менять до показа. */ + var shopId: String? = null + + /** Загрузчик картинок; `null` — Glide из SDK. */ + var imageLoader: ((ImageView, String) -> Unit)? = null + + /** Клики по ссылкам и товарам — контракт старых сторис ([com.personalization.OnClickListener]). */ + var onClickListener: com.personalization.OnClickListener? = null + + /** Блок не загрузился: код ошибки (HTTP или -1) и сообщение. Виджет при этом скрыт. */ + var onError: ((code: Int, message: String?) -> Unit)? = null + + var promoCaption: CharSequence + var promoCopiedText: CharSequence + var productButtonText: CharSequence + var showProductsText: CharSequence + var hideProductsText: CharSequence + var retryText: CharSequence + var closeLabel: CharSequence + var soundOnLabel: CharSequence + var soundOffLabel: CharSequence + + /** Загруженные сторис — в порядке сервера, без пустых. */ + var stories: List = emptyList() + private set + + private var sdk: SDK? = null + private var instanceHandle: Cancellable? = null + private var viewer: PersonalizationStoriesViewer? = null + private var requestSeq = 0 + private var pendingOpen: (() -> Unit)? = null + private val giveUp = Runnable { fail(StoriesLoader.ERROR_CODE, "stories: no response in ${LOAD_TIMEOUT_MS / 1000} s") } + + init { + val defaults = StoriesTexts.defaults(context) + promoCaption = defaults.promoCaption + promoCopiedText = defaults.promoCopiedText + productButtonText = defaults.productButtonText + showProductsText = defaults.showProductsText + hideProductsText = defaults.hideProductsText + retryText = defaults.retryText + closeLabel = defaults.closeLabel + soundOnLabel = defaults.soundOnLabel + soundOffLabel = defaults.soundOffLabel + attrs?.let { + val array = context.obtainStyledAttributes(it, R.styleable.PersonalizationStories) + code = array.getString(R.styleable.PersonalizationStories_code) + shopId = array.getString(R.styleable.PersonalizationStories_shop_id) + array.recycle() + } + addView(bar, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT)) + bar.onItemClick = { index, _ -> open(index) } + // Загрузчик ставится один раз: каждая установка перерисовывает ленту. + bar.imageLoader = { view, url -> imageLoader?.invoke(view, url) ?: SearchImages.load(view, url, firstFrame = true) } + bar.showSkeleton() + } + + /** Явный инстанс SDK; блок загружается сразу. */ + fun attach(sdk: SDK) { + instanceHandle?.cancel() + instanceHandle = null + this.sdk = sdk + reload() + } + + /** Перезагрузить блок [code]. */ + fun reload() { + val blockCode = code?.takeIf { it.isNotBlank() } ?: run { + fail(StoriesLoader.ERROR_CODE, "PersonalizationStories: code is not set") + return + } + val sdk = sdk ?: return + val seq = ++requestSeq + if (stories.isEmpty()) { + visibility = View.VISIBLE + bar.showSkeleton() + } + startGiveUp() + StoriesLoader.load( + sdk, + blockCode, + onLoaded = { loaded -> + if (seq == requestSeq) { + removeCallbacks(giveUp) + stories = loaded + render() + pendingOpen?.also { pendingOpen = null }?.invoke() + } + }, + onFailed = { code, message -> if (seq == requestSeq) fail(code, message) } + ) + } + + /** + * Открыть просмотр со сторис [index]. До загрузки блока — откроется, когда он придёт. + * Просмотр уже открыт — листает к ней в нём, не пересоздавая его (F11). + */ + fun open(index: Int) { + if (stories.isEmpty()) { + pendingOpen = { open(index) } + return + } + val story = stories.getOrNull(index) ?: return + if (viewer?.showStory(story.id) == true) return + viewer?.dismiss() + viewer = newViewer(context, stories, index).also { viewer -> + viewer.setOnDismissListener { + if (this.viewer === viewer) this.viewer = null + render() + } + viewer.show() + } + } + + /** Открыть просмотр со сторис с id [storyId]. */ + fun openStory(storyId: Int) { + if (stories.isEmpty()) { + pendingOpen = { openStory(storyId) } + return + } + stories.indexOfFirst { it.id == storyId }.takeIf { it >= 0 }?.let(::open) + } + + /** То же по id строкой — как его отдают другие платформы (F12). Не число — ничего. */ + fun openStory(storyId: String) { + storyId.trim().toIntOrNull()?.let { openStory(it) } + } + + /** Пауза открытого просмотра (B8); без просмотра — ничего. */ + fun pause() { + viewer?.pause() + } + + fun resume() { + viewer?.resume() + } + + override fun onAttachedToWindow() { + super.onAttachedToWindow() + if (sdk != null || stories.isNotEmpty()) return + startGiveUp() + instanceHandle = try { + Rees46.awaitInstance(shopId) { resolved -> MainThread.run { attach(resolved) } } + } catch (throwable: Throwable) { + fail( + StoriesLoader.ERROR_CODE, + "PersonalizationStories: cannot resolve an SDK for shopId=$shopId — set app:shop_id " + + "to pick a shop when several are registered. ${throwable.message}" + ) + null + } + } + + override fun onDetachedFromWindow() { + instanceHandle?.cancel() + instanceHandle = null + removeCallbacks(giveUp) + viewer?.dismiss() + viewer = null + super.onDetachedFromWindow() + } + + private fun startGiveUp() { + removeCallbacks(giveUp) + postDelayed(giveUp, LOAD_TIMEOUT_MS) + } + + /** Ошибка: поздний ответ уже не нужен, пустой блок прячется, хост узнаёт. */ + private fun fail(code: Int, message: String?) { + removeCallbacks(giveUp) + requestSeq++ + instanceHandle?.cancel() + instanceHandle = null + pendingOpen = null + SDK.error("PersonalizationStories: $code $message") + if (stories.isEmpty()) visibility = View.GONE + onError?.invoke(code, message) + } + + private fun render() { + visibility = if (stories.isEmpty()) View.GONE else View.VISIBLE + val seen = StoriesSeenStore.forSdk(context, sdk, shopId) + bar.items = stories.map { StoriesMapping.item(it, seen.seen(it.id)) } + } + + private fun texts() = StoriesTexts( + promoCaption, promoCopiedText, productButtonText, showProductsText, hideProductsText, + retryText, closeLabel, soundOnLabel, soundOffLabel + ) + + private fun newViewer(context: Context, stories: List, index: Int) = + PersonalizationStoriesViewer(context, stories, index).also { viewer -> + viewer.code = code + viewer.sdk = sdk + viewer.shopId = shopId + viewer.imageLoader = imageLoader + viewer.onClickListener = this@PersonalizationStories.onClickListener + viewer.applyTexts(texts()) + } + + companion object { + /** Сколько ждать блок, прежде чем сдаться и спрятать виджет. */ + internal const val LOAD_TIMEOUT_MS = 15_000L + + /** + * Показать сторис блока [code] без ленты (B8): загрузить блок и открыть просмотр + * со сторис [startStoryId] (нет такой — с первой). SDK — [sdk], иначе инстанс + * магазина [shopId]. Тексты `null` — по умолчанию из ресурсов. + * + * Пустой блок, ошибка загрузки, магазин не найден или 15 с без ответа — [onError], + * и показ на этом заканчивается. Просмотр закрыли — [onClose] (F12; на RN и Flutter + * так завершаются Promise и Future). Возвращает отмену ещё не открытого показа. + */ + @JvmStatic + @JvmOverloads + fun show( + context: Context, + code: String, + sdk: SDK? = null, + shopId: String? = null, + startStoryId: Int? = null, + onClickListener: com.personalization.OnClickListener? = null, + onError: ((code: Int, message: String?) -> Unit)? = null, + onClose: (() -> Unit)? = null, + imageLoader: ((ImageView, String) -> Unit)? = null, + promoCaption: CharSequence? = null, + promoCopiedText: CharSequence? = null, + productButtonText: CharSequence? = null, + showProductsText: CharSequence? = null, + hideProductsText: CharSequence? = null, + retryText: CharSequence? = null, + closeLabel: CharSequence? = null, + soundOnLabel: CharSequence? = null, + soundOffLabel: CharSequence? = null + ): Cancellable { + val widget = PersonalizationStories(context).also { widget -> + widget.code = code + widget.shopId = shopId + widget.onClickListener = onClickListener + widget.onError = onError + widget.imageLoader = imageLoader + promoCaption?.let { widget.promoCaption = it } + promoCopiedText?.let { widget.promoCopiedText = it } + productButtonText?.let { widget.productButtonText = it } + showProductsText?.let { widget.showProductsText = it } + hideProductsText?.let { widget.hideProductsText = it } + retryText?.let { widget.retryText = it } + closeLabel?.let { widget.closeLabel = it } + soundOnLabel?.let { widget.soundOnLabel = it } + soundOffLabel?.let { widget.soundOffLabel = it } + } + return widget.showDetached(sdk, startStoryId, onClose) + } + } + + /** + * Показ без ленты: виджет не на экране, поэтому SDK и таймаут ведутся вручную, + * а просмотр открывается, как только блок пришёл. + */ + private fun showDetached(explicitSdk: SDK?, startStoryId: Int?, onClose: (() -> Unit)?): Cancellable { + val handler = android.os.Handler(android.os.Looper.getMainLooper()) + handler.postDelayed(giveUp, LOAD_TIMEOUT_MS) + pendingOpen = open@{ + handler.removeCallbacks(giveUp) + if (stories.isEmpty()) { + onError?.invoke(StoriesLoader.ERROR_CODE, "PersonalizationStories.show: block $code is empty") + return@open + } + val index = startStoryId?.let { id -> stories.indexOfFirst { it.id == id } }?.takeIf { it >= 0 } ?: 0 + newViewer(context, stories, index).apply { + setOnDismissListener { onClose?.invoke() } + show() + } + } + val previousError = onError + onError = { code, message -> + handler.removeCallbacks(giveUp) + previousError?.invoke(code, message) + } + if (explicitSdk != null) { + attach(explicitSdk) + } else { + instanceHandle = try { + Rees46.awaitInstance(shopId) { resolved -> MainThread.run { attach(resolved) } } + } catch (throwable: Throwable) { + fail(StoriesLoader.ERROR_CODE, "PersonalizationStories.show: cannot resolve an SDK for shopId=$shopId. ${throwable.message}") + null + } + } + return Cancellable { + handler.removeCallbacks(giveUp) + requestSeq++ + pendingOpen = null + instanceHandle?.cancel() + instanceHandle = null + } + } +} diff --git a/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/PersonalizationStoriesViewer.kt b/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/PersonalizationStoriesViewer.kt new file mode 100644 index 00000000..49e9d057 --- /dev/null +++ b/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/PersonalizationStoriesViewer.kt @@ -0,0 +1,868 @@ +package com.personalization.ui.widgets + +import android.app.Dialog +import android.content.Context +import android.content.res.Configuration +import android.graphics.Bitmap +import android.graphics.Color +import android.graphics.drawable.ColorDrawable +import android.graphics.drawable.Drawable +import android.media.AudioManager +import android.os.Build +import android.os.Bundle +import android.os.Handler +import android.os.Looper +import android.view.KeyEvent +import android.view.ViewGroup +import android.view.WindowManager +import android.widget.FrameLayout +import android.widget.ImageView +import androidx.core.graphics.Insets +import androidx.core.view.ViewCompat +import androidx.core.view.WindowCompat +import androidx.core.view.WindowInsetsCompat +import androidx.lifecycle.Lifecycle +import androidx.lifecycle.LifecycleEventObserver +import androidx.media3.exoplayer.ExoPlayer +import androidx.viewpager2.widget.ViewPager2 +import com.bumptech.glide.Glide +import com.bumptech.glide.load.DataSource +import com.bumptech.glide.load.engine.GlideException +import com.bumptech.glide.load.resource.gif.GifDrawable +import com.bumptech.glide.request.RequestListener +import com.bumptech.glide.request.target.CustomViewTarget +import com.bumptech.glide.request.target.Target +import com.bumptech.glide.request.transition.Transition +import com.personalization.OnClickListener +import com.personalization.SDK +import com.personalization.stories.models.Story +import com.personalization.ui.InternalPersonalizationUiApi +import com.personalization.ui.widgets.StoriesViewerState.Pause + +/** + * Полноэкранный просмотр сторис (V2) — на компонентах кита. + * + * Паттерн Stories из Figma (страница 1:32): слайд со скримом, сверху + * [com.personalization.ui.components.PersonalizationStoryNavigation], дальше по содержимому — + * карточка товара или текстовые блоки, кнопки и «Используемые товары» (см. [StorySlideView]). + * + * Логика — в [StoriesViewerState]: тап по трети ширины, удержание — пауза, свайп вбок — + * соседняя сторис, вниз — закрыть; сторис открывается с первого невиденного слайда, и + * увиденное хранится по магазину. Пауза и при уходе в фон, потере фокуса, погасшем экране. + * + * Ссылки и товары — через [onClickListener] с контрактом старых сторис: `true` — SDK + * открывает сам, `false` — хост обработал. Перед переходом просмотр закрывается. + * + * Модели — те же, что у старого `StoriesView`: V2 его не трогает. + */ +@InternalPersonalizationUiApi +class PersonalizationStoriesViewer( + context: Context, + stories: List, + startStory: Int = 0 +) : Dialog(context, android.R.style.Theme_Translucent_NoTitleBar) { + + /** Контекст хоста: вьюхи строятся в его теме, чтобы работал брендинг кита. */ + private val hostContext = context + + /** Сторис без слайдов не показываются (C16). */ + private val stories: List = stories.filter { it.slidesCount > 0 } + private var startIndex: Int = stories.getOrNull(startStory)?.let { this.stories.indexOf(it) }?.takeIf { it >= 0 } ?: 0 + + /** Код блока — для трекинга. */ + var code: String? = null + + /** Инстанс SDK: трекинг и хранилище увиденного магазина. Без него сторис просто показываются. */ + var sdk: SDK? = null + + /** Магазин для хранилища увиденного, если [sdk] не зарегистрирован в реестре. */ + var shopId: String? = null + + /** Загрузчик картинок; `null` — Glide из SDK. */ + var imageLoader: ((ImageView, String) -> Unit)? = null + + /** Клики по ссылкам и товарам — контракт старых сторис ([OnClickListener]). */ + var onClickListener: OnClickListener? = null + + var promoCaption: CharSequence + var promoCopiedText: CharSequence + var productButtonText: CharSequence + var showProductsText: CharSequence + var hideProductsText: CharSequence + var retryText: CharSequence + var closeLabel: CharSequence + var soundOnLabel: CharSequence + var soundOffLabel: CharSequence + + init { + val defaults = StoriesTexts.defaults(context) + promoCaption = defaults.promoCaption + promoCopiedText = defaults.promoCopiedText + productButtonText = defaults.productButtonText + showProductsText = defaults.showProductsText + hideProductsText = defaults.hideProductsText + retryText = defaults.retryText + closeLabel = defaults.closeLabel + soundOnLabel = defaults.soundOnLabel + soundOffLabel = defaults.soundOffLabel + } + + private lateinit var state: StoriesViewerState + private lateinit var root: StoryDismissLayout + private lateinit var pager: ViewPager2 + private lateinit var texts: StoriesTexts + private val pages = HashMap() + private val handler = Handler(Looper.getMainLooper()) + private val frameClock = StoryFrameClock(::onFrame) + private val readyTimer = StoryTimer(handler) { onReadyTimeout() } + private val videoRetryTimer = StoryTimer(handler) { currentSlideView()?.let(::retry) } + private var player: ExoPlayer? = null + private var playerSlide: StorySlideView? = null + private var audioFocus: StoriesAudioFocus? = null + private val sound = StoriesSound() + private var insets: Insets = Insets.NONE + private var hostLifecycle: Lifecycle? = null + private var created = false + private var dismissed = false + private var hostStopped = false + private var windowFocused = true + private var hostPaused = false + private var dismissDragging = false + private var pagerDragging = false + + /** Поставить просмотр на паузу из кода хоста (B8). */ + fun pause() = setHostPaused(true) + + /** Снять паузу хоста. */ + fun resume() = setHostPaused(false) + + /** + * Открыть сторис [storyId] в уже открытом просмотре (F11): пейджер листает к ней, просмотр + * не пересоздаётся. `false` — такой сторис в просмотре нет или он уже закрыт. + */ + internal fun showStory(storyId: Int): Boolean { + if (dismissed) return false + val index = stories.indexOfFirst { it.id == storyId } + if (index < 0) return false + if (!created) { + startIndex = index + return true + } + if (state.sheetOpen) currentSlideView()?.closeSheet() + apply(state.jumpTo(index)) + return true + } + + private fun setHostPaused(paused: Boolean) { + hostPaused = paused + if (!created) return + state.setPaused(Pause.HOST, paused) + sync() + } + + internal fun applyTexts(texts: StoriesTexts) { + promoCaption = texts.promoCaption + promoCopiedText = texts.promoCopiedText + productButtonText = texts.productButtonText + showProductsText = texts.showProductsText + hideProductsText = texts.hideProductsText + retryText = texts.retryText + closeLabel = texts.closeLabel + soundOnLabel = texts.soundOnLabel + soundOffLabel = texts.soundOffLabel + } + + override fun onCreate(savedInstanceState: Bundle?) { + super.onCreate(savedInstanceState) + texts = StoriesTexts( + promoCaption, promoCopiedText, productButtonText, showProductsText, hideProductsText, + retryText, closeLabel, soundOnLabel, soundOffLabel + ) + val seen = StoriesSeenStore.forSdk(hostContext, sdk, shopId) + state = StoriesViewerState(stories.map(::shape), seen, startIndex) + state.setPaused(Pause.HOST, hostPaused) + created = true + setupWindow() + + root = StoryDismissLayout(hostContext).apply { + canDrag = { !state.sheetOpen } + onDragChange = { dragging -> + dismissDragging = dragging + updateDrag() + } + onDismiss = { dismiss() } + } + pager = ViewPager2(hostContext).apply { + adapter = StoriesAdapter() + offscreenPageLimit = 1 + registerOnPageChangeCallback(pageCallback) + } + root.addView(pager, FrameLayout.LayoutParams(FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT)) + ViewCompat.setOnApplyWindowInsetsListener(root) { _, windowInsets -> + insets = windowInsets.getInsets(WindowInsetsCompat.Type.systemBars() or WindowInsetsCompat.Type.displayCutout()) + pages.values.forEach { it.slideView?.applyInsets(insets) } + WindowInsetsCompat.CONSUMED + } + setContentView(root) + volumeControlStream = AudioManager.STREAM_MUSIC + audioFocus = StoriesAudioFocus(hostContext) { silence() } + observeHost() + + if (stories.isEmpty()) { + handler.post { dismiss() } + return + } + pager.setCurrentItem(state.storyIndex, false) + // Для начальной страницы пейджер onPageSelected может не прислать. + handler.post { enterCurrent() } + } + + /** Окно во весь экран: медиа уходит под панели и вырез, органы управления — нет. */ + private fun setupWindow() { + val window = window ?: return + window.setBackgroundDrawable(ColorDrawable(Color.BLACK)) + window.setLayout(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT) + WindowCompat.setDecorFitsSystemWindows(window, false) + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) { + window.statusBarColor = Color.TRANSPARENT + window.navigationBarColor = Color.TRANSPARENT + } + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) { + window.attributes = window.attributes.apply { + layoutInDisplayCutoutMode = WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES + } + } + } + + /** Значки панелей светлые над медиа и тёмные на светлой теме хоста. */ + private fun applySystemBars(view: StorySlideView) { + val window = window ?: return + val night = (hostContext.resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK) == + Configuration.UI_MODE_NIGHT_YES + val light = !view.isMedia && !night + WindowCompat.getInsetsController(window, window.decorView).apply { + isAppearanceLightStatusBars = light + isAppearanceLightNavigationBars = light + } + } + + /** Хост ушёл в фон, его закрыло другое окно, погас экран — пауза (B6). */ + private fun observeHost() { + val lifecycle = hostContext.findLifecycleOwner()?.lifecycle ?: return + hostLifecycle = lifecycle + hostStopped = !lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED) + lifecycle.addObserver(hostObserver) + setBackground() + } + + private val hostObserver = LifecycleEventObserver { _, event -> + when (event) { + Lifecycle.Event.ON_START -> setBackground(stopped = false) + Lifecycle.Event.ON_STOP -> setBackground(stopped = true) + Lifecycle.Event.ON_DESTROY -> dismiss() + else -> Unit + } + } + + private fun setBackground(stopped: Boolean = hostStopped) { + hostStopped = stopped + if (!created) return + val background = hostStopped || !windowFocused + state.setPaused(Pause.BACKGROUND, background) + // Ожидание готовности и автоповтор видео в фоне стоят и потом идут с остатка (F5). + readyTimer.freeze(background) + videoRetryTimer.freeze(background) + sync() + } + + override fun onWindowFocusChanged(hasFocus: Boolean) { + super.onWindowFocusChanged(hasFocus) + windowFocused = hasFocus + setBackground() + } + + /** «Назад» сначала закрывает шторку товаров (B5). */ + @Deprecated("Dialog still routes back here, also through OnBackInvokedDispatcher on API 33+") + override fun onBackPressed() { + if (!created) { + @Suppress("DEPRECATION") + super.onBackPressed() + return + } + apply(state.back()) + } + + /** Кнопка громкости вверх включает звук (C7); громкость меняет система, как обычно. */ + override fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean { + if (keyCode == KeyEvent.KEYCODE_VOLUME_UP && sound.muted) setMuted(false) + return super.onKeyDown(keyCode, event) + } + + override fun dismiss() { + if (created && !dismissed) { + dismissed = true + frameClock.stop() + handler.removeCallbacksAndMessages(null) + state.leave() + stopMedia() + player?.release() + player = null + audioFocus?.abandon() + hostLifecycle?.removeObserver(hostObserver) + pages.clear() + } + super.dismiss() + } + + // --- Навигация ------------------------------------------------------------------------- + + private fun shape(story: Story) = StoriesViewerState.StoryShape( + id = story.id, + slides = List(story.slidesCount) { index -> + val slide = story.getSlide(index) + StoriesViewerState.SlideShape(slide.id, StoriesMapping.durationMs(slide)) + }, + serverViewed = story.isViewed, + startPosition = story.startPosition + ) + + private fun currentPage(): StoryPage? = pages[state.storyIndex] + + private fun currentSlideView(): StorySlideView? = currentPage()?.slideView + + /** Какой слайд показывает страница: у текущей — текущий, у соседних — стартовый (A4). */ + private fun slideFor(index: Int): Int = if (index == state.storyIndex) state.slideIndex else state.startSlideOf(index) + + private val pageCallback = object : ViewPager2.OnPageChangeCallback() { + override fun onPageSelected(position: Int) { + if (!created || dismissed) return + if (position != state.storyIndex) { + stopMedia() + state.selectStory(position) + pages[position]?.showSlide(state.slideIndex) + } + if (pager.scrollState == ViewPager2.SCROLL_STATE_IDLE) enterCurrent() + sync() + } + + override fun onPageScrollStateChanged(scrollState: Int) { + if (!created || dismissed) return + pagerDragging = scrollState == ViewPager2.SCROLL_STATE_DRAGGING + updateDrag() + // Страница, на которой пейджер остановился, — показанная (A1), подсмотренная — нет. + if (scrollState == ViewPager2.SCROLL_STATE_IDLE) enterCurrent() + } + } + + private fun updateDrag() { + if (!created) return + state.setPaused(Pause.DRAG, dismissDragging || pagerDragging) + sync() + } + + private fun enterCurrent() { + if (!created || dismissed) return + // Ушедшие сторис откроются по правилу A4 — их страницы показывают стартовый слайд. + pages.forEach { (index, page) -> if (index != state.storyIndex) page.showSlide(slideFor(index)) } + if (state.enter()) onSlideStarted() + sync() + } + + /** Слайд стал текущим на остановившейся странице: трекинг, медиа, предзагрузка. */ + private fun onSlideStarted() { + track("view") + preloadNext() + // Страницы может ещё не быть: тогда медиа запустит привязка адаптера. + val page = currentPage() ?: return + page.showSlide(state.slideIndex) + page.slideView?.let(::startMedia) + } + + private fun apply(move: StoriesViewerState.Move) { + if (dismissed) return + when (move) { + StoriesViewerState.Move.None -> Unit + StoriesViewerState.Move.Slide -> { + stopMedia() + onSlideStarted() + } + is StoriesViewerState.Move.Story -> { + stopMedia() + pager.setCurrentItem(move.index, true) + } + StoriesViewerState.Move.Restart -> { + val view = currentSlideView() + if (view != null && view === playerSlide) player?.seekTo(0) + view?.restartAnimation() + view?.setProgress(0f) + } + StoriesViewerState.Move.CloseSheet -> currentSlideView()?.closeSheet() + StoriesViewerState.Move.Close -> { + dismiss() + return + } + } + sync() + } + + /** Привести часы, плеер, пейджер и фокус звука к состоянию. */ + private fun sync() { + if (!created || dismissed) return + if (state.isRunning) frameClock.start() else frameClock.stop() + player?.playWhenReady = playerSlide != null && state.playerShouldPlay + currentSlideView()?.setAnimationRunning(state.isRunning) + pager.isUserInputEnabled = !state.sheetOpen + currentSlideView()?.setProgress(state.progress) + updateAudioFocus() + } + + private fun onFrame(deltaMs: Long) { + if (!created || dismissed) return + val view = currentSlideView() + val exo = player + if (state.clock == StoriesViewerState.Clock.PLAYER && exo != null && view != null && view === playerSlide) { + state.videoPosition(exo.currentPosition) + } + val move = state.tick(deltaMs) + view?.setProgress(state.progress) + if (move != StoriesViewerState.Move.None) apply(move) + } + + // --- Слайд: касания и клики ------------------------------------------------------------- + + private val slideHost = object : StorySlideHost { + override val texts: StoriesTexts get() = this@PersonalizationStoriesViewer.texts + override val muted: Boolean get() = sound.muted + override val sheetOpen: Boolean get() = created && state.sheetOpen + override val insets: Insets get() = this@PersonalizationStoriesViewer.insets + + override fun loadImage(view: ImageView, url: String, onReady: (() -> Unit)?, onFailed: (() -> Unit)?) = + this@PersonalizationStoriesViewer.loadImage(view, url, onReady, onFailed) + + override fun loadSlideImage( + view: ImageView, + url: String, + onAnimation: (Long?, GifDrawable) -> Unit, + onReady: () -> Unit, + onFailed: () -> Unit + ) = this@PersonalizationStoriesViewer.loadSlideImage(view, url, onAnimation, onReady, onFailed) + + override fun onTap(x: Float, width: Int, rtl: Boolean) = apply(state.tap(StoriesViewerState.zone(x, width, rtl))) + + override fun onHold(hold: Boolean) { + if (!created) return + state.setPaused(Pause.HOLD, hold) + sync() + } + + override fun onOutsideSheetTap() = apply(state.tap(StoriesViewerState.Zone.CENTER)) + + override fun onSheet(open: Boolean) { + if (!created || state.sheetOpen == open) return + state.setSheet(open) + sync() + } + + override fun onButton(button: com.personalization.stories.models.elements.ButtonElement, product: com.personalization.Product?) { + track("click") + val link = button.link + when { + link.isNotEmpty() -> { + dismiss() + if (clicks.onClick(link)) openUrl(link) + } + // Кнопка без ссылки открывает товар слайда (C11). + product != null -> openProduct(product) + } + } + + override fun onProduct(product: com.personalization.Product) { + track("click") + openProduct(product) + } + + /** Карусель — как у старых сторис: `onCloseDialogClick` решает, закрыть или открыть. */ + override fun onCarouselProduct(product: com.personalization.Product) { + track("click") + val url = StoriesMapping.productLink(product) + when { + !clicks.onClick(product) -> dismiss() + clicks.onCloseDialogClick(product, url) -> dismiss() + else -> openUrl(url) + } + } + + override fun onPromoCopied() = track("click") + + override fun onSoundToggle() = setMuted(!sound.muted) + + override fun onRetry(view: StorySlideView) = retry(view) + + override fun onClose() = dismiss() + } + + private val clicks: OnClickListener get() = onClickListener ?: DEFAULT_CLICKS + + private fun openProduct(product: com.personalization.Product) { + dismiss() + if (clicks.onClick(product)) openUrl(StoriesMapping.productLink(product)) + } + + private fun openUrl(url: String) { + if (url.isEmpty()) return + val activity = hostContext.findActivity() + val intent = android.content.Intent(android.content.Intent.ACTION_VIEW, android.net.Uri.parse(url)) + if (activity == null) intent.addFlags(android.content.Intent.FLAG_ACTIVITY_NEW_TASK) + try { + (activity ?: hostContext).startActivity(intent) + } catch (_: android.content.ActivityNotFoundException) { + SDK.error("PersonalizationStoriesViewer: no app can open $url") + } + } + + /** `view` и `click` с кодом блока; id не целые положительные — не трекаются (A6). */ + private fun track(event: String) { + if (!created) return + val blockCode = code ?: return + val story = stories.getOrNull(state.storyIndex) ?: return + if (state.slideIndex !in 0 until story.slidesCount) return + val slide = story.getSlide(state.slideIndex) + if (!StoriesMapping.isTrackable(story.id, slide.id)) return + runCatching { sdk?.storiesManager?.trackStory(event, blockCode, story.id, slide.id) } + } + + /** Картинка компонента: у GIF только первый кадр (G6). */ + private fun loadImage(view: ImageView, url: String, onReady: (() -> Unit)?, onFailed: (() -> Unit)?) { + val loader = imageLoader + if (loader != null) { + // Загрузчик хоста о себе не сообщает: готовность видна по картинке во вьюхе. + loader(view, url) + return + } + Glide.with(view).asBitmap().load(url) + .listener(object : RequestListener { + override fun onLoadFailed( + e: GlideException?, + model: Any?, + target: Target, + isFirstResource: Boolean + ): Boolean { + onFailed?.invoke() + return false + } + + override fun onResourceReady( + resource: Bitmap, + model: Any, + target: Target?, + dataSource: DataSource, + isFirstResource: Boolean + ): Boolean { + onReady?.invoke() + return false + } + }) + .into(view) + } + + /** + * Фон слайда: GIF здесь играет (G1). Своя цель вместо обычной: Glide сам запускает GIF + * при показе и на `onStart` хоста, а он должен идти только вместе с часами слайда (G5). + * Проход и сам GIF отдаются до того, как картинка встанет во вьюху: по ней слайд готов. + */ + private fun loadSlideImage( + view: ImageView, + url: String, + onAnimation: (Long?, GifDrawable) -> Unit, + onReady: () -> Unit, + onFailed: () -> Unit + ) { + val loader = imageLoader + if (loader != null) { + // GIF загрузчика хоста SDK не трогает и не меряет (G8). + loader(view, url) + return + } + Glide.with(view).load(url).into(object : CustomViewTarget(view) { + override fun onResourceReady(resource: Drawable, transition: Transition?) { + if (resource is GifDrawable) { + resource.setLoopCount(GifDrawable.LOOP_FOREVER) + onAnimation(StoriesGif.loopMs(resource.buffer), resource) + } + this.view.setImageDrawable(resource) + onReady() + } + + override fun onLoadFailed(errorDrawable: Drawable?) = onFailed() + + override fun onResourceCleared(placeholder: Drawable?) { + (this.view.drawable as? GifDrawable)?.stop() + this.view.setImageDrawable(placeholder) + } + }) + } + + // --- Медиа ----------------------------------------------------------------------------- + + /** + * Часы слайда пойдут, когда медиа готово (C5): картинка загружена, видео играет. + * Не готово за 10 с или ошибка — пауза и «Повторить». Время в фоне не считается (F5): + * Glide на `onStop` хоста ставит загрузки на паузу без ошибки и сам продолжает их на + * `onStart`, а ожидание готовности тем временем заморожено. + */ + private fun startMedia(view: StorySlideView) { + if (view.mediaStarted || dismissed) return + view.mediaStarted = true + applySystemBars(view) + cancelMediaTimers() + when { + view.isVideo -> attachVideo(view) + view.isMedia -> { + view.onImageState = { onImageState(view) } + onImageState(view) + } + else -> onMediaReady(view, null) + } + if (view.isMedia) readyTimer.start(READY_TIMEOUT_MS) + } + + private fun onImageState(view: StorySlideView) { + when (view.imageState) { + StorySlideView.ImageState.READY -> onMediaReady(view, null) + StorySlideView.ImageState.FAILED -> onMediaFailed(view) + StorySlideView.ImageState.LOADING -> Unit + } + } + + private fun onMediaReady(view: StorySlideView, videoDurationMs: Long?) { + if (view !== currentSlideView() || dismissed) return + view.mediaReadyOnce = true + cancelMediaTimers() + view.showRetry(false) + state.mediaReady(videoDurationMs, view.animationLoopMs) + sync() + } + + private fun onMediaFailed(view: StorySlideView) { + if (view !== currentSlideView() || dismissed) return + readyTimer.cancel() + state.mediaFailed() + view.showRetry(true) + // Видео пробует ещё раз само; картинка — по кнопке. + if (view.isVideo) videoRetryTimer.start(VIDEO_RETRY_MS) + sync() + } + + private fun onReadyTimeout() { + val view = currentSlideView() ?: return + if (!view.mediaReadyOnce && !state.hasError) onMediaFailed(view) + } + + private fun retry(view: StorySlideView) { + if (view !== currentSlideView() || dismissed) return + cancelMediaTimers() + if (view === playerSlide) detachPlayer() + view.showRetry(false) + view.mediaStarted = false + view.mediaReadyOnce = false + state.retry() + if (!view.isVideo) view.loadImage() + startMedia(view) + sync() + } + + private fun cancelMediaTimers() { + readyTimer.cancel() + videoRetryTimer.cancel() + } + + /** Уход со слайда: таймеры и повторы отменяются, плеер отдан, GIF стоит. */ + private fun stopMedia() { + cancelMediaTimers() + detachPlayer() + currentSlideView()?.stopAnimation() + } + + @androidx.annotation.OptIn(markerClass = [androidx.media3.common.util.UnstableApi::class]) + private fun obtainPlayer(): ExoPlayer = player ?: ExoPlayer.Builder(hostContext) + .setMediaSourceFactory(StoriesMediaCache.mediaSourceFactory(hostContext)) + .build() + .also { exo -> + exo.repeatMode = androidx.media3.common.Player.REPEAT_MODE_OFF + exo.addListener(playerListener) + player = exo + applyVolume() + } + + private fun attachVideo(view: StorySlideView) { + val exo = obtainPlayer() + detachPlayer() + playerSlide = view + view.playerView?.player = exo + exo.setMediaItem(androidx.media3.common.MediaItem.fromUri(view.slide.background)) + exo.prepare() + exo.playWhenReady = state.playerShouldPlay + } + + private fun detachPlayer() { + val view = playerSlide ?: return + playerSlide = null + player?.let { exo -> + exo.stop() + exo.clearMediaItems() + } + view.playerView?.player = null + updateAudioFocus() + } + + private val playerListener = object : androidx.media3.common.Player.Listener { + override fun onPlaybackStateChanged(playbackState: Int) { + val view = playerSlide ?: return + val exo = player ?: return + when (playbackState) { + androidx.media3.common.Player.STATE_READY -> + if (!view.mediaReadyOnce) { + val duration = exo.duration.takeIf { it != androidx.media3.common.C.TIME_UNSET && it > 0 } + onMediaReady(view, duration) + } else { + state.buffering(false) + sync() + } + // Подгрузка посреди ролика — прогресс стоит (C4). + androidx.media3.common.Player.STATE_BUFFERING -> if (view.mediaReadyOnce) { + state.buffering(true) + sync() + } + androidx.media3.common.Player.STATE_ENDED -> if (view === currentSlideView()) apply(state.mediaEnded()) + else -> Unit + } + } + + override fun onRenderedFirstFrame() { + playerSlide?.hidePoster() + } + + override fun onPlayerError(error: androidx.media3.common.PlaybackException) { + SDK.error("PersonalizationStoriesViewer: video failed", error) + playerSlide?.let(::onMediaFailed) + } + + override fun onPlayWhenReadyChanged(playWhenReady: Boolean, reason: Int) { + // Выдернули наушники: ролик идёт дальше без звука, выбор звука не меняется (F6). + if (reason == androidx.media3.common.Player.PLAY_WHEN_READY_CHANGE_REASON_AUDIO_BECOMING_NOISY) { + silence() + sync() + } + } + } + + /** Звук включил или выключил пользователь: выбор запоминается на весь процесс (C7). */ + private fun setMuted(value: Boolean) { + sound.choose(value) + applySound() + } + + /** Звонок, другой плеер, выдернутые наушники: глушится только это воспроизведение (F6). */ + private fun silence() { + if (sound.silence()) applySound() + } + + private fun applySound() { + applyVolume() + pages.values.forEach { it.slideView?.setMuted(sound.muted) } + updateAudioFocus() + } + + private fun applyVolume() { + val exo = player ?: return + exo.volume = if (sound.muted) 0f else 1f + exo.setHandleAudioBecomingNoisy(!sound.muted) + } + + /** Фокус берётся, только пока звук включён и видео на экране (C7). */ + private fun updateAudioFocus() { + val focus = audioFocus ?: return + val wanted = created && !dismissed && !sound.muted && playerSlide != null && !state.isPaused(Pause.BACKGROUND) + if (wanted) focus.request() else focus.abandon() + } + + /** Следующий слайд — заранее (C6): картинка или превью и начало видео. */ + private fun preloadNext() { + val story = stories.getOrNull(state.storyIndex) ?: return + val next = when { + state.slideIndex + 1 < story.slidesCount -> story.getSlide(state.slideIndex + 1) + state.storyIndex + 1 < stories.size -> + stories[state.storyIndex + 1].getSlide(state.startSlideOf(state.storyIndex + 1)) + else -> return + } + if (StoriesMapping.isVideo(next)) { + StoriesMediaCache.preloadVideo(hostContext, next.background) + preloadImage(next.preview) + } else if (StoriesMapping.isMedia(next)) { + preloadImage(next.background) + } + } + + private fun preloadImage(url: String) { + if (url.isEmpty() || imageLoader != null) return + com.bumptech.glide.Glide.with(hostContext.applicationContext).load(url).preload() + } + + private inner class StoriesAdapter : androidx.recyclerview.widget.RecyclerView.Adapter() { + override fun getItemCount(): Int = stories.size + + override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): androidx.recyclerview.widget.RecyclerView.ViewHolder { + val page = StoryPage(hostContext) + page.layoutParams = ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT) + return object : androidx.recyclerview.widget.RecyclerView.ViewHolder(page) {} + } + + override fun onBindViewHolder(holder: androidx.recyclerview.widget.RecyclerView.ViewHolder, position: Int) { + val page = holder.itemView as StoryPage + pages.entries.removeAll { it.value === page } + pages[position] = page + page.bind(position) + if (position == state.storyIndex && state.entered) page.slideView?.let(::startMedia) + } + + override fun onViewRecycled(holder: androidx.recyclerview.widget.RecyclerView.ViewHolder) { + val page = holder.itemView as StoryPage + if (page.slideView != null && page.slideView === playerSlide) stopMedia() + pages.entries.removeAll { it.value === page } + } + } + + /** Страница одной сторис: держит вьюху показанного слайда. */ + private inner class StoryPage(context: Context) : FrameLayout(context) { + var storyIndex = -1 + private set + var slideView: StorySlideView? = null + private set + + fun bind(index: Int) { + storyIndex = index + showSlide(slideFor(index), force = true) + } + + /** Слайд строится заново, если он другой или его медиа уже запускали. */ + fun showSlide(index: Int, force: Boolean = false) { + val story = stories.getOrNull(storyIndex) ?: return + if (index !in 0 until story.slidesCount) return + val current = slideView + if (!force && current != null && current.slideIndex == index && !current.mediaStarted) return + if (current != null && current === playerSlide) stopMedia() + removeAllViews() + val view = StorySlideView(context, storyIndex, index, story.getSlide(index), story.slidesCount, slideHost) + slideView = view + addView(view, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)) + } + } + + private companion object { + /** Без слушателя хоста — поведение по умолчанию из контракта: SDK открывает сам. */ + val DEFAULT_CLICKS = object : OnClickListener {} + + const val READY_TIMEOUT_MS = 10_000L + const val VIDEO_RETRY_MS = 15_000L + } +} diff --git a/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/PersonalizationStoriesWidget.kt b/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/PersonalizationStoriesWidget.kt new file mode 100644 index 00000000..cc457cf7 --- /dev/null +++ b/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/PersonalizationStoriesWidget.kt @@ -0,0 +1,116 @@ +package com.personalization.ui.widgets + +import android.widget.ImageView +import androidx.compose.runtime.Composable +import androidx.compose.runtime.key +import androidx.compose.runtime.rememberUpdatedState +import androidx.compose.ui.Modifier +import androidx.compose.ui.viewinterop.AndroidView +import com.personalization.OnClickListener +import com.personalization.SDK +import com.personalization.ui.InternalPersonalizationUiApi + +/** + * Управление сторис из Compose (B8): то же, что методы [PersonalizationStories]. + * Передаётся в [PersonalizationStoriesWidget]. Открытие до показа виджета ждёт его, как + * ждёт загрузки блока (F11); пауза и остальное без виджета ничего не делают. + */ +@InternalPersonalizationUiApi +class PersonalizationStoriesController { + + internal var view: PersonalizationStories? = null + set(value) { + field = value + if (value != null) pendingOpen?.also { pendingOpen = null }?.invoke(value) + } + + /** Последнее открытие, вызванное до показа виджета. */ + private var pendingOpen: ((PersonalizationStories) -> Unit)? = null + + fun open(index: Int) = openWhenShown { it.open(index) } + + fun openStory(storyId: Int) = openWhenShown { it.openStory(storyId) } + + /** То же по id строкой (F12). */ + fun openStory(storyId: String) = openWhenShown { it.openStory(storyId) } + + private fun openWhenShown(action: (PersonalizationStories) -> Unit) { + val target = view + if (target != null) action(target) else pendingOpen = action + } + + fun pause() { + view?.pause() + } + + fun resume() { + view?.resume() + } + + fun reload() { + view?.reload() + } +} + +/** + * Compose-обёртка над [PersonalizationStories] — те же параметры, что у вьюхи. + * Compose у SDK опциональный (`compileOnly`), как у старого `StoriesWidget`: хост + * подключает его сам. Тексты `null` — по умолчанию из ресурсов SDK. + * + * ```kotlin + * PersonalizationStoriesWidget(code = "STORIES_CODE", onClickListener = listener) + * ``` + */ +@InternalPersonalizationUiApi +@Composable +fun PersonalizationStoriesWidget( + code: String, + modifier: Modifier = Modifier, + shopId: String? = null, + sdk: SDK? = null, + controller: PersonalizationStoriesController? = null, + onClickListener: OnClickListener? = null, + onError: ((code: Int, message: String?) -> Unit)? = null, + imageLoader: ((ImageView, String) -> Unit)? = null, + promoCaption: CharSequence? = null, + promoCopiedText: CharSequence? = null, + productButtonText: CharSequence? = null, + showProductsText: CharSequence? = null, + hideProductsText: CharSequence? = null, + retryText: CharSequence? = null, + closeLabel: CharSequence? = null, + soundOnLabel: CharSequence? = null, + soundOffLabel: CharSequence? = null +) { + val currentOnError = rememberUpdatedState(onError) + // Код, магазин и SDK задают, какой блок грузить, — их смена пересоздаёт вьюху. + key(code, shopId, sdk) { + AndroidView( + modifier = modifier, + factory = { context -> + PersonalizationStories(context).apply { + this.code = code + this.shopId = shopId + this.onError = { errorCode, message -> currentOnError.value?.invoke(errorCode, message) } + sdk?.let(::attach) + } + }, + update = { view -> + val defaults = StoriesTexts.defaults(view.context) + view.onClickListener = onClickListener + view.imageLoader = imageLoader + view.promoCaption = promoCaption ?: defaults.promoCaption + view.promoCopiedText = promoCopiedText ?: defaults.promoCopiedText + view.productButtonText = productButtonText ?: defaults.productButtonText + view.showProductsText = showProductsText ?: defaults.showProductsText + view.hideProductsText = hideProductsText ?: defaults.hideProductsText + view.retryText = retryText ?: defaults.retryText + view.closeLabel = closeLabel ?: defaults.closeLabel + view.soundOnLabel = soundOnLabel ?: defaults.soundOnLabel + view.soundOffLabel = soundOffLabel ?: defaults.soundOffLabel + controller?.view = view + }, + onRelease = { view -> if (controller?.view === view) controller.view = null } + ) + } +} diff --git a/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/SearchSupport.kt b/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/SearchSupport.kt index f68c9a28..95e3b19a 100644 --- a/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/SearchSupport.kt +++ b/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/SearchSupport.kt @@ -86,7 +86,8 @@ internal fun storageKey(sdk: SDK, requestedShopId: String?): String = * После layout размер известен, и Glide стартует сразу. */ internal object SearchImages { - fun load(imageView: ImageView, url: String?) { + /** [firstFrame] — у GIF только первый кадр: так рисуются обложки сторис (G6). */ + fun load(imageView: ImageView, url: String?, firstFrame: Boolean = false) { imageView.tag = url if (url.isNullOrEmpty()) { Glide.with(imageView).clear(imageView) @@ -95,7 +96,9 @@ internal object SearchImages { } imageView.doOnLayout { view -> // Пока ждали layout, view могла уйти под другой товар. - if (view.tag == url) Glide.with(view).load(url).into(view as ImageView) + if (view.tag != url) return@doOnLayout + val request = Glide.with(view) + if (firstFrame) request.asBitmap().load(url).into(view as ImageView) else request.load(url).into(view as ImageView) } } } diff --git a/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/StoriesGif.kt b/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/StoriesGif.kt new file mode 100644 index 00000000..8a66fc0b --- /dev/null +++ b/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/StoriesGif.kt @@ -0,0 +1,91 @@ +package com.personalization.ui.widgets + +import java.nio.ByteBuffer +import java.nio.ByteOrder + +/** + * Длина одного прохода GIF по его байтам (G2): сумма задержек кадров, задержка короче 20 мс + * (и нулевая) считается за 100 мс — как в браузерах. GIF узнаём по подписи, не по адресу (G1). + */ +internal object StoriesGif { + + private const val MIN_DELAY_MS = 20L + private const val FALLBACK_DELAY_MS = 100L + + /** Байты начинаются с подписи GIF87a или GIF89a. */ + fun isGif(bytes: ByteBuffer): Boolean { + val data = bytes.duplicate() + data.position(0) + if (data.remaining() < 6) return false + val head = ByteArray(6).also { data.get(it) } + val signature = String(head, Charsets.US_ASCII) + return signature == "GIF87a" || signature == "GIF89a" + } + + /** Задержки кадров, мс, уже с поправкой на короткие; `null` — не GIF или файл битый. */ + fun frameDelaysMs(bytes: ByteBuffer): List? { + if (!isGif(bytes)) return null + val data = bytes.duplicate().order(ByteOrder.LITTLE_ENDIAN) + data.position(6) + return runCatching { readFrames(data) }.getOrNull()?.takeIf { it.isNotEmpty() } + } + + /** Длина одного прохода, мс; `null` — не GIF или файл битый. */ + fun loopMs(bytes: ByteBuffer): Long? = frameDelaysMs(bytes)?.sum() + + private fun readFrames(data: ByteBuffer): List { + data.short // ширина + data.short // высота + val packed = data.get().toInt() and 0xFF + data.get() // фон + data.get() // пропорции пикселя + if (packed and 0x80 != 0) skip(data, 3 * (1 shl ((packed and 0x07) + 1))) + + val delays = ArrayList() + var pendingDelayCs = 0 + while (data.hasRemaining()) { + when (data.get().toInt() and 0xFF) { + 0x21 -> { + val label = data.get().toInt() and 0xFF + if (label == 0xF9) { + val size = data.get().toInt() and 0xFF + val start = data.position() + data.get() // флаги + pendingDelayCs = data.short.toInt() and 0xFFFF + data.position(start + size) + } + skipSubBlocks(data) + } + 0x2C -> { + skip(data, 8) // положение и размер кадра + val flags = data.get().toInt() and 0xFF + if (flags and 0x80 != 0) skip(data, 3 * (1 shl ((flags and 0x07) + 1))) + data.get() // минимальный размер кода LZW + skipSubBlocks(data) + delays += delayMs(pendingDelayCs) + pendingDelayCs = 0 + } + 0x3B -> return delays + else -> return delays + } + } + return delays + } + + private fun delayMs(centiseconds: Int): Long { + val ms = centiseconds * 10L + return if (ms < MIN_DELAY_MS) FALLBACK_DELAY_MS else ms + } + + private fun skip(data: ByteBuffer, count: Int) { + data.position(data.position() + count) + } + + private fun skipSubBlocks(data: ByteBuffer) { + while (true) { + val size = data.get().toInt() and 0xFF + if (size == 0) return + skip(data, size) + } + } +} diff --git a/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/StoriesMedia.kt b/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/StoriesMedia.kt new file mode 100644 index 00000000..64253b7d --- /dev/null +++ b/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/StoriesMedia.kt @@ -0,0 +1,183 @@ +package com.personalization.ui.widgets + +import android.content.Context +import android.media.AudioAttributes +import android.media.AudioFocusRequest +import android.media.AudioManager +import android.net.Uri +import android.os.Build +import androidx.annotation.RequiresApi +import androidx.media3.common.util.UnstableApi +import androidx.media3.database.StandaloneDatabaseProvider +import androidx.media3.datasource.DataSpec +import androidx.media3.datasource.DefaultDataSource +import androidx.media3.datasource.DefaultHttpDataSource +import androidx.media3.datasource.cache.CacheDataSource +import androidx.media3.datasource.cache.CacheWriter +import androidx.media3.datasource.cache.LeastRecentlyUsedCacheEvictor +import androidx.media3.datasource.cache.SimpleCache +import androidx.media3.exoplayer.source.DefaultMediaSourceFactory +import androidx.media3.exoplayer.source.MediaSource +import com.personalization.SDK +import java.io.File +import java.util.concurrent.Executors + +/** + * Дисковый кэш видео сторис V2 (C6): LRU на 50 МБ в `cacheDir/personalization_stories`, + * один на процесс — его делят все просмотры. Старые сторис держат свой кэш в другой папке: + * две `SimpleCache` на одной папке не уживаются. + * + * Чтение идёт с [CacheDataSource.FLAG_BLOCK_ON_CACHE]: пока предзагрузка качает начало + * ролика, плеер ждёт её, а не тянет те же байты второй раз. + */ +@androidx.annotation.OptIn(markerClass = [UnstableApi::class]) +internal object StoriesMediaCache { + + private const val FOLDER = "personalization_stories" + private const val MAX_BYTES = 50L * 1024 * 1024 + + /** Сколько начала ролика качать заранее: хватает на первые секунды. */ + private const val PRELOAD_BYTES = 1024L * 1024 + + private var cache: SimpleCache? = null + private val preloading = HashSet() + private val executor = Executors.newSingleThreadExecutor { runnable -> + Thread(runnable, "personalization-stories-preload").apply { isDaemon = true } + } + + @Synchronized + private fun cache(context: Context): SimpleCache = cache ?: SimpleCache( + File(context.applicationContext.cacheDir, FOLDER), + LeastRecentlyUsedCacheEvictor(MAX_BYTES), + StandaloneDatabaseProvider(context.applicationContext) + ).also { cache = it } + + private fun dataSourceFactory(context: Context): CacheDataSource.Factory { + val http = DefaultHttpDataSource.Factory() + .setUserAgent(SDK.userAgent()) + .setAllowCrossProtocolRedirects(true) + return CacheDataSource.Factory() + .setCache(cache(context)) + .setUpstreamDataSourceFactory(DefaultDataSource.Factory(context.applicationContext, http)) + .setFlags(CacheDataSource.FLAG_BLOCK_ON_CACHE or CacheDataSource.FLAG_IGNORE_CACHE_ON_ERROR) + } + + /** Источник для плеера: сеть через кэш. */ + fun mediaSourceFactory(context: Context): MediaSource.Factory = + DefaultMediaSourceFactory(dataSourceFactory(context)) + + /** Начало ролика — в кэш заранее, чтобы следующий слайд пошёл сразу. Дубли не качаются. */ + fun preloadVideo(context: Context, url: String) { + if (!url.startsWith("http")) return + synchronized(preloading) { if (!preloading.add(url)) return } + val factory = dataSourceFactory(context) + executor.execute { + try { + val spec = DataSpec.Builder().setUri(Uri.parse(url)).setLength(PRELOAD_BYTES).build() + CacheWriter(factory.createDataSourceForDownloading(), spec, null, null).cache() + } catch (_: Throwable) { + // Предзагрузка — только ускорение: не вышло — ролик докачается при показе. + } finally { + synchronized(preloading) { preloading.remove(url) } + } + } + } +} + +/** + * Звук просмотра сторис (C7, F6). Выбор пользователя ([chosenMuted]) живёт до конца процесса: + * первый просмотр без звука, дальше — как выбрали. Потеря аудиофокуса (звонок, другой плеер) + * и выдернутые наушники только глушат текущее воспроизведение ([silence]): выбор остаётся, + * и следующий просмотр откроется с ним. Сам пользователь звук возвращает кнопкой или + * громкостью вверх ([choose]). + */ +internal class StoriesSound { + + /** Звук заглушён системой в этом просмотре. */ + var silenced = false + private set + + /** Звука сейчас нет: так выбрал пользователь или заглушила система. */ + val muted: Boolean get() = chosenMuted || silenced + + /** Выбор пользователя: он запоминается, заглушение снимается. */ + fun choose(muted: Boolean) { + chosenMuted = muted + silenced = false + } + + /** Заглушить текущее воспроизведение, не трогая выбор. `true` — звук был и пропал. */ + fun silence(): Boolean { + if (muted) return false + silenced = true + return true + } + + companion object { + /** Выбор пользователя на весь процесс; первый просмотр — без звука. */ + @Volatile + var chosenMuted = true + internal set + } +} + +/** + * Аудиофокус видео сторис (C7). Пока звук выключен, фокус не берётся — музыка других + * приложений играет дальше. Включённый звук берёт временный фокус: чужой плеер встаёт + * на паузу и сам продолжит, когда просмотр отдаст фокус (выключил звук, закрыл). + * Потеря фокуса (звонок, другой плеер) глушит текущее воспроизведение — [onLoss] (F6). + */ +internal class StoriesAudioFocus(context: Context, private val onLoss: () -> Unit) { + + private val audioManager = context.applicationContext.getSystemService(Context.AUDIO_SERVICE) as? AudioManager + private var held = false + private var request: Any? = null + + private val listener = AudioManager.OnAudioFocusChangeListener { change -> + if (change == AudioManager.AUDIOFOCUS_LOSS || change == AudioManager.AUDIOFOCUS_LOSS_TRANSIENT) { + abandon() + onLoss() + } + } + + fun request() { + val manager = audioManager ?: return + if (held) return + held = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { + Api26.request(manager, listener).also { request = it.second }.first + } else { + @Suppress("DEPRECATION") + manager.requestAudioFocus(listener, AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN_TRANSIENT) == + AudioManager.AUDIOFOCUS_REQUEST_GRANTED + } + } + + fun abandon() { + val manager = audioManager ?: return + if (!held) return + held = false + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { + (request as? AudioFocusRequest)?.let { manager.abandonAudioFocusRequest(it) } + } else { + @Suppress("DEPRECATION") + manager.abandonAudioFocus(listener) + } + request = null + } + + @RequiresApi(Build.VERSION_CODES.O) + private object Api26 { + fun request(manager: AudioManager, listener: AudioManager.OnAudioFocusChangeListener): Pair { + val request = AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN_TRANSIENT) + .setAudioAttributes( + AudioAttributes.Builder() + .setUsage(AudioAttributes.USAGE_MEDIA) + .setContentType(AudioAttributes.CONTENT_TYPE_MOVIE) + .build() + ) + .setOnAudioFocusChangeListener(listener) + .build() + return (manager.requestAudioFocus(request) == AudioManager.AUDIOFOCUS_REQUEST_GRANTED) to request + } + } +} diff --git a/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/StoriesSupport.kt b/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/StoriesSupport.kt new file mode 100644 index 00000000..44165b16 --- /dev/null +++ b/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/StoriesSupport.kt @@ -0,0 +1,378 @@ +package com.personalization.ui.widgets + +import android.content.Context +import android.content.SharedPreferences +import android.graphics.Color +import com.personalization.PreferencesPartition +import com.personalization.Product +import com.personalization.SDK +import com.personalization.api.OnApiCallbackListener +import com.personalization.stories.models.Slide +import com.personalization.stories.models.Story +import com.personalization.stories.models.elements.ButtonElement +import com.personalization.stories.models.elements.ProductElement +import com.personalization.stories.models.elements.ProductsElement +import com.personalization.stories.models.elements.TextBlockElement +import com.personalization.ui.InternalPersonalizationUiApi +import com.personalization.ui.components.PersonalizationProduct +import com.personalization.ui.components.PersonalizationStoryCover +import com.personalization.ui.components.PersonalizationStoryItem +import com.personalization.ui.components.PersonalizationStoryPrice +import com.personalization.ui.components.PersonalizationStoryTextBlock +import java.math.BigDecimal +import org.json.JSONObject + +/** + * Перевод моделей сторис SDK (те же, что у старого `StoriesView`) в данные компонентов кита. + * Отдельно от вьюх — чтобы проверялось тестами без экрана. + */ +@InternalPersonalizationUiApi +internal object StoriesMapping { + + /** Длительность слайда, когда админка её не задала или задала 0 (A7). */ + const val DEFAULT_DURATION_MS = 10_000L + + /** Скрим медиа-слайда без текста и товара — 50%, всех остальных — 30% (C3). */ + const val SCRIM_STRONG = 128 + const val SCRIM_LIGHT = 77 + + /** Цена товара на слайде: промокод важнее скидки, скидка важнее просто цены. */ + data class Price( + val type: PersonalizationStoryPrice.Type, + val price: String, + val oldPrice: String?, + val discount: String?, + val promoCode: String? + ) + + /** + * Цена товарного слайда (C10, F10). Старая цена имеет смысл, только если она численно + * больше обычной. С промокодом крупно — цена по промокоду, зачёркнута старая цена, а без + * неё — обычная, если она выше цены по промокоду (F10). Скидка — процент как есть, + * с дробной частью. + * + * [slidePromo] — промокод текстового блока того же слайда (H2): сами блоки на товарном + * слайде не рисуются, а код идёт в блок цены, как в макете, если у товара своего нет. + * Цена тогда обычная, зачёркнута только старая (H3). + */ + fun price(product: Product, slidePromo: String? = null): Price { + val regular = product.priceDecimal ?: Decimals.parse(product.price) + val old = product.oldPrice.takeIf { + it.isNotEmpty() && Decimals.greater(product.oldPriceDecimal ?: Decimals.parse(it), regular) + } + val promo = product.promocode.trim().takeIf { it.isNotEmpty() && it != "null" } + if (promo != null) { + val withPromo = product.priceWithPromocode.takeIf { it.isNotEmpty() } + val promoValue = withPromo?.let { product.priceWithPromocodeDecimal ?: Decimals.parse(it) } + val crossed = when { + old != null -> old + Decimals.greater(regular, promoValue) -> product.price + else -> null + } + return Price(PersonalizationStoryPrice.Type.PROMO_CODE, withPromo ?: product.price, crossed, null, promo) + } + if (slidePromo != null) { + return Price(PersonalizationStoryPrice.Type.PROMO_CODE, product.price, old, null, slidePromo) + } + val percent = Decimals.parse(product.discountPercent)?.takeIf { it.signum() > 0 } + if (percent != null) { + val text = percent.stripTrailingZeros().toPlainString() + "%" + return Price(PersonalizationStoryPrice.Type.DISCOUNT, product.price, old, text, null) + } + return Price(PersonalizationStoryPrice.Type.PRICE, product.price, old, null, null) + } + + /** Товар карусели «Используемые товары» → карточка кита. */ + fun cardProduct(product: Product): PersonalizationProduct { + val regular = product.priceDecimal ?: Decimals.parse(product.price) + val old = product.oldPrice.takeIf { + it.isNotEmpty() && Decimals.greater(product.oldPriceDecimal ?: Decimals.parse(it), regular) + } + val discount = product.discount.takeIf { old != null && it.isNotEmpty() && it != "0" } + ?.let { if (it.endsWith("%")) it else "$it%" } + ?.let { if (it.startsWith("-")) it else "-$it" } + return PersonalizationProduct( + id = product.id, + name = product.name, + price = product.price, + imageUrl = product.image.takeIf { it.isNotEmpty() }, + brand = product.brand.takeIf { it.isNotEmpty() }, + oldPrice = old, + discount = discount + ) + } + + fun slideIds(story: Story): List = List(story.slidesCount) { story.getSlide(it).id } + + /** Сторис просмотрена: так сказал сервер или видны все её слайды (A3). */ + fun isViewed(story: Story, seen: Set): Boolean = isViewed(slideIds(story), seen, story.isViewed) + + fun isViewed(slideIds: List, seen: Set, serverViewed: Boolean): Boolean = + serverViewed || (slideIds.isNotEmpty() && slideIds.all { it in seen }) + + /** + * С какого слайда открыть сторис (A4): часть слайдов видна — с первого невиденного; + * не видно ничего — с `start_position` сервера; просмотрена — с начала. + */ + fun startSlide(slideIds: List, seen: Set, serverViewed: Boolean, startPosition: Int): Int { + if (slideIds.isEmpty()) return 0 + if (isViewed(slideIds, seen, serverViewed)) return 0 + val firstUnseen = slideIds.indexOfFirst { it !in seen } + if (slideIds.any { it in seen }) return firstUnseen + return startPosition.coerceIn(0, slideIds.lastIndex) + } + + fun startSlide(story: Story, seen: Set): Int = + startSlide(slideIds(story), seen, story.isViewed, story.startPosition) + + /** + * Обложка в ленте (A5). Закреплённая — всегда кольцо Semantic/Warning со звездой; + * просмотренная — сплошное кольцо без сегментов (у закреплённой — сплошное + * предупреждающее). Частично просмотренная — сегмент i отмечен, если виден слайд i. + */ + fun item(story: Story, seen: Set): PersonalizationStoryItem { + val viewed = isViewed(story, seen) + val state = when { + story.isPinned -> PersonalizationStoryCover.State.PINNED + viewed -> PersonalizationStoryCover.State.VIEWED + else -> PersonalizationStoryCover.State.DEFAULT + } + val ids = slideIds(story) + return PersonalizationStoryItem( + id = story.id.toString(), + title = story.name, + imageUrl = story.avatar.takeIf { it.isNotEmpty() }, + state = state, + segments = if (viewed) 1 else ids.size.coerceAtLeast(1), + seenSegments = if (viewed) emptySet() else ids.indices.filterTo(HashSet()) { ids[it] in seen } + ) + } + + /** Время слайда из админки; нет или 0 — 10 с (A7). Видео идёт по своей длине (C4). */ + fun durationMs(slide: Slide): Long = + if (slide.adminDurationSeconds > 0) slide.adminDurationSeconds * 1000L else DEFAULT_DURATION_MS + + /** + * Трекаются только целые положительные id (A6): динамические товарные слайды + * приходят с id вида `39_0`, и сервер их не принимает. + */ + fun isTrackable(storyId: Int, slideId: String): Boolean { + if (storyId <= 0) return false + val number = slideId.toLongOrNull() ?: return false + return number > 0 && number.toString() == slideId + } + + fun product(slide: Slide): ProductElement? = + slide.getElements().filterIsInstance().firstOrNull { it.item != null } + + fun products(slide: Slide): ProductsElement? = + slide.getElements().filterIsInstance().firstOrNull { it.getProducts().isNotEmpty() } + + fun buttons(slide: Slide): List = + slide.getElements().filterIsInstance().filter { it.title.isNotBlank() } + + /** Пустые текстовые блоки пропускаются (C15). */ + fun textBlocks(slide: Slide): List = + slide.getElements().filterIsInstance().filter { it.textInput.isNotBlank() } + + /** Медиа-слайд — с картинкой или видео фоном: он рисуется тёмными токенами. */ + fun isMedia(slide: Slide): Boolean = slide.background.isNotEmpty() + + fun isVideo(slide: Slide): Boolean = slide.type == "video" && slide.background.isNotEmpty() + + /** + * Длина слайда с GIF (G2): большее из времени админки и одного прохода GIF. Проход + * неизвестен (загрузчик хоста, файл не разобрали) — время админки. + */ + fun animatedDurationMs(serverMs: Long, loopMs: Long?): Long = + if (loopMs == null || loopMs <= 0) serverMs else maxOf(serverMs, loopMs) + + /** Скрим сверху и снизу есть у каждого слайда; 50% — только у голого медиа (C3). */ + fun scrimAlpha(slide: Slide): Int { + val bare = isMedia(slide) && product(slide) == null && textBlocks(slide).isEmpty() + return if (bare) SCRIM_STRONG else SCRIM_LIGHT + } + + /** Поля вокруг вписанного медиа: цвет слайда, без него чёрный (C1). */ + fun letterboxColor(slide: Slide): Int = parseColor(slide.backgroundColor) ?: Color.BLACK + + /** Ссылка товара: сначала диплинк платформы, потом сайт. */ + fun productLink(product: Product): String = product.deeplink.ifEmpty { product.url } + + /** + * Куда ведёт кнопка (C11): своя ссылка (`link_android`, затем `link` — так её уже + * собирает модель), без неё — товар слайда. + */ + fun buttonLink(button: ButtonElement, product: Product?): String = + button.link.ifEmpty { product?.let(::productLink).orEmpty() } + + /** Подпись над промокодом (C9): `title` элемента товара, без него — текст хоста. */ + fun promoCaption(element: ProductElement, fallback: CharSequence): CharSequence = + element.title.trim().ifEmpty { fallback } + + /** Промокод текстового блока (C12); модель отдаёт `"null"` для явного null. */ + fun textPromocode(element: TextBlockElement): String? = + element.promocode?.trim()?.takeIf { it.isNotEmpty() && it != "null" } + + /** Промокод слайда для блока цены товара (H2): первый текстовый блок с непустым кодом. */ + fun slidePromocode(slide: Slide): String? = + slide.getElements().filterIsInstance().firstNotNullOfOrNull(::textPromocode) + + /** Интерлиньяж из админки; без него — `null`, и блок берёт высоту строки пресета. */ + fun lineHeightSp(element: TextBlockElement): Float? = + if (element.textLineSpacing > 0) (element.fontSize * element.textLineSpacing).toFloat() else null + + /** Подложка текстового блока: цвет админки с её прозрачностью; 0% — блок без фона. */ + fun textBlockColor(element: TextBlockElement): Int? { + val opacity = element.textBackgroundColorOpacity.trim().removeSuffix("%").toIntOrNull() ?: 0 + if (opacity <= 0) return null + val color = parseColor(element.textBackgroundColor) ?: return null + val alpha = (opacity.coerceAtMost(100) * 255) / 100 + return Color.argb(alpha, Color.red(color), Color.green(color), Color.blue(color)) + } + + fun textAlign(element: TextBlockElement): PersonalizationStoryTextBlock.Align = when (element.textAlign.trim().lowercase()) { + "center" -> PersonalizationStoryTextBlock.Align.CENTER + "right", "end" -> PersonalizationStoryTextBlock.Align.END + else -> PersonalizationStoryTextBlock.Align.START + } + + fun parseColor(value: String?): Int? = + value?.takeIf { it.isNotBlank() }?.let { runCatching { Color.parseColor(it.trim()) }.getOrNull() } +} + +/** + * Числа из ответа сервера. Сырые поля (`price`, `oldprice`) — десятичные; если их нет, + * число достаётся из отформатированной строки (`"1 190 900 ₽"`, `"19,99 €"`, + * `"1,190.50 $"`): последний разделитель с одной-двумя цифрами после него — дробный. + */ +internal object Decimals { + + fun greater(left: BigDecimal?, right: BigDecimal?): Boolean = + left != null && right != null && left > right + + fun parse(text: String?): BigDecimal? { + val raw = text?.trim().orEmpty() + if (raw.isEmpty()) return null + raw.toBigDecimalOrNull()?.let { return it } + val kept = raw.filter { it.isDigit() || it == '.' || it == ',' } + if (kept.none { it.isDigit() }) return null + val lastDot = kept.lastIndexOf('.') + val lastComma = kept.lastIndexOf(',') + val separator = when { + lastDot >= 0 && lastComma >= 0 -> maxOf(lastDot, lastComma) + lastDot >= 0 -> lastDot.takeIf { kept.count { it == '.' } == 1 && kept.length - lastDot - 1 in 1..2 } + lastComma >= 0 -> lastComma.takeIf { kept.count { it == ',' } == 1 && kept.length - lastComma - 1 in 1..2 } + else -> null + } + val normalized = buildString { + kept.forEachIndexed { index, char -> + when { + char.isDigit() -> append(char) + index == separator -> append('.') + } + } + } + return normalized.toBigDecimalOrNull() + } +} + +/** Просмотренные слайды: id сторис → id слайдов. */ +internal interface SeenSlides { + fun seen(storyId: Int): Set + fun markSeen(storyId: Int, slideId: String) +} + +/** + * Просмотренные слайды магазина (A2): переживают перезапуск приложения. Свой файл + * SharedPreferences рядом с файлом магазина — то же разбиение, что у SDK + * ([PreferencesPartition.keyFor]); ключ — id сторис, значение — набор id слайдов. + * Лента и просмотр одного магазина делят один экземпляр. + */ +internal class StoriesSeenStore internal constructor(private val preferences: SharedPreferences?) : SeenSlides { + + private val memory = HashMap>() + + @Synchronized + override fun seen(storyId: Int): Set = HashSet(slides(storyId)) + + @Synchronized + override fun markSeen(storyId: Int, slideId: String) { + val slides = slides(storyId) + if (!slides.add(slideId)) return + preferences?.edit()?.putStringSet(key(storyId), HashSet(slides))?.apply() + } + + private fun slides(storyId: Int): MutableSet = memory.getOrPut(storyId) { + HashSet(preferences?.getStringSet(key(storyId), null).orEmpty()) + } + + private fun key(storyId: Int) = "$KEY_PREFIX$storyId" + + companion object { + private const val FILE_SUFFIX = "_stories" + private const val KEY_PREFIX = "seen." + private val stores = HashMap() + + /** Хранилище только в памяти — для просмотра без SDK (витрина, тесты). */ + val local: StoriesSeenStore by lazy { StoriesSeenStore(null) } + + fun forShop(context: Context, shopKey: String): StoriesSeenStore = synchronized(stores) { + stores.getOrPut(shopKey) { + StoriesSeenStore( + context.applicationContext.getSharedPreferences( + PreferencesPartition.keyFor(shopKey) + FILE_SUFFIX, + Context.MODE_PRIVATE + ) + ) + } + } + + fun forSdk(context: Context, sdk: SDK?, requestedShopId: String?): StoriesSeenStore = + if (sdk == null) local else forShop(context, storageKey(sdk, requestedShopId)) + } +} + +/** + * Загрузка сторис-блока для V2. Тот же запрос, что у старого `StoriesView`, но с ошибкой: + * её надо показать хосту, а не крутить скелетон вечно. Ответ — на главном потоке. + */ +internal object StoriesLoader { + + fun load(sdk: SDK, code: String, onLoaded: (List) -> Unit, onFailed: (Int, String?) -> Unit) { + val listener = object : OnApiCallbackListener() { + override fun onSuccess(response: JSONObject?) { + val stories = try { + parse(response) + } catch (throwable: Throwable) { + MainThread.run { onFailed(ERROR_CODE, "stories/$code: ${throwable.message}") } + return + } + MainThread.run { onLoaded(stories) } + } + + override fun onError(code: Int, msg: String?) { + MainThread.run { onFailed(code, msg) } + } + } + try { + sdk.storiesManager.requestStories(code, listener) + } catch (throwable: Throwable) { + MainThread.run { onFailed(ERROR_CODE, throwable.message) } + } + } + + /** + * Сторис без слайдов выбрасываются (C16): их нечего показывать. Повтор id тоже — сервер + * иногда отдаёт одну сторис дважды; остаётся первая, иначе просмотренность склеивается. + */ + fun parse(response: JSONObject?): List { + val array = response?.optJSONArray("stories") ?: return emptyList() + return List(array.length()) { Story(array.getJSONObject(it)) } + .filter { it.slidesCount > 0 } + .distinctBy { it.id } + } + + /** Код ошибки, которая случилась до сервера или без кода HTTP. */ + const val ERROR_CODE = -1 +} diff --git a/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/StoriesViewerState.kt b/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/StoriesViewerState.kt new file mode 100644 index 00000000..0c526e85 --- /dev/null +++ b/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/StoriesViewerState.kt @@ -0,0 +1,349 @@ +package com.personalization.ui.widgets + +/** + * Логика полноэкранного просмотра сторис без вьюх (E1): где мы (сторис и слайд), с какого + * слайда открыть сторис, почему слайд на паузе, сколько он уже идёт, открыта ли шторка. + * + * Вьюер только рисует и передаёт сюда события — касания, тики часов, готовность медиа, + * уход в фон — и выполняет возвращённый [Move]. Сторис, на которую переходим, становится + * текущей, когда пейджер на неё встал ([selectStory]), а начинает идти — когда он + * остановился ([enter]): подсмотренная наполовину страница не считается показанной (A1). + */ +internal class StoriesViewerState( + private val stories: List, + private val seen: SeenSlides, + startStory: Int = 0 +) { + + /** Сторис глазами просмотра. */ + data class StoryShape( + val id: Int, + val slides: List, + val serverViewed: Boolean = false, + val startPosition: Int = 0 + ) + + /** Слайд: id и время из админки (уже с умолчанием A7). */ + data class SlideShape(val id: String, val durationMs: Long) + + /** + * Почему слайд стоит. Часы идут, только когда причин нет; плеер играет и при + * [LOADING] (иначе видео не догрузится), и не играет при остальных. + */ + enum class Pause { + /** Палец держит слайд (B2). */ + HOLD, + + /** Слайд тянут — вниз, чтобы закрыть, или вбок, к соседней сторис (B4). */ + DRAG, + + /** Открыта шторка товаров (B5). */ + SHEET, + + /** Приложение в фоне, окно без фокуса, экран погас (B6). */ + BACKGROUND, + + /** Пауза хоста — `pause()` виджета (B8). */ + HOST, + + /** Медиа ещё не готово или видео подгружается (C4, C5). */ + LOADING, + + /** Медиа не загрузилось — на слайде кнопка «Повторить» (C5). */ + ERROR + } + + /** Зона тапа (B1). */ + enum class Zone { PREVIOUS, CENTER, NEXT } + + /** Откуда идёт время слайда. */ + enum class Clock { + /** Таймер: время из админки. */ + TIMER, + + /** Позиция видео: длина ролика известна (C4). */ + PLAYER + } + + /** Что сделать вьюеру после события. */ + sealed class Move { + /** Ничего не меняется. */ + object None : Move() + + /** Текущий слайд сменился внутри сторис — перерисовать и запустить его. */ + object Slide : Move() + + /** Перейти к сторис [index]: пейджер листает, потом зовёт [selectStory] и [enter]. */ + data class Story(val index: Int) : Move() + + /** Начать текущий слайд сначала — прогресс и видео с нуля (B3). */ + object Restart : Move() + + /** Закрыть шторку товаров, никуда не листая (B5). */ + object CloseSheet : Move() + + /** Закрыть просмотр. */ + object Close : Move() + } + + var storyIndex: Int = startStory.coerceIn(0, (stories.size - 1).coerceAtLeast(0)) + private set + + var slideIndex: Int = 0 + private set + + /** Сторис идёт: пейджер на ней остановился. */ + var entered: Boolean = false + private set + + var sheetOpen: Boolean = false + private set + + private val pauses = HashSet() + + var clock: Clock = Clock.TIMER + private set + + /** Сколько слайд уже идёт, мс. */ + var elapsedMs: Long = 0 + private set + + /** Длина текущего слайда, мс. */ + var durationMs: Long = 0 + private set + + init { + slideIndex = startSlideOf(storyIndex) + resetSlide() + } + + val storyCount: Int get() = stories.size + + val story: StoryShape? get() = stories.getOrNull(storyIndex) + + val slide: SlideShape? get() = story?.slides?.getOrNull(slideIndex) + + val pauseReasons: Set get() = pauses + + /** Часы слайда идут. */ + val isRunning: Boolean get() = entered && slide != null && pauses.isEmpty() + + /** Видео должно играть: всё, кроме подгрузки и ошибки, его останавливает. */ + val playerShouldPlay: Boolean + get() = entered && pauses.none { it != Pause.LOADING && it != Pause.ERROR } + + /** Заполнение текущей полоски прогресса, 0…1. */ + val progress: Float + get() = if (durationMs <= 0) 0f else (elapsedMs.toFloat() / durationMs).coerceIn(0f, 1f) + + fun isPaused(reason: Pause): Boolean = reason in pauses + + /** Слайд, с которого откроется сторис [index] (A4). */ + fun startSlideOf(index: Int): Int { + val shape = stories.getOrNull(index) ?: return 0 + return StoriesMapping.startSlide( + shape.slides.map { it.id }, + seen.seen(shape.id), + shape.serverViewed, + shape.startPosition + ) + } + + /** Пейджер выбрал сторис [index]: она становится текущей и откроется по правилу A4. */ + fun selectStory(index: Int) { + if (index == storyIndex || index !in stories.indices) return + entered = false + storyIndex = index + slideIndex = startSlideOf(index) + resetSlide() + } + + /** + * Пейджер остановился на текущей сторис — она пошла: слайд показан, он просмотрен (A1). + * Возвращает `true`, если слайд только что начался: вьюер трекает `view` и грузит медиа. + */ + fun enter(): Boolean { + if (entered || slide == null) return false + entered = true + startSlide() + return true + } + + /** Сторис ушла с экрана (просмотр закрыт или свёрнут насовсем). */ + fun leave() { + entered = false + } + + fun next(): Move { + val shape = story ?: return away(Move.Close) + return when { + slideIndex + 1 < shape.slides.size -> { + slideIndex++ + startSlide() + Move.Slide + } + storyIndex + 1 < stories.size -> away(Move.Story(storyIndex + 1)) + else -> away(Move.Close) + } + } + + fun previous(): Move = when { + slideIndex > 0 -> { + slideIndex-- + startSlide() + Move.Slide + } + storyIndex > 0 -> away(Move.Story(storyIndex - 1)) + else -> { + // Первый слайд первой сторис начинается заново (B3). + elapsedMs = 0 + Move.Restart + } + } + + /** + * Хост открывает сторис [index], пока просмотр открыт (F11): листаем к ней в нём же. + * Шторка закрывается; сторис откроется по правилу A4, когда пейджер на неё встанет. + */ + fun jumpTo(index: Int): Move { + if (index !in stories.indices || index == storyIndex) return Move.None + if (sheetOpen) setSheet(false) + return away(Move.Story(index)) + } + + /** + * Уходим со сторис: часы стоят, пока пейджер не встанет на соседнюю, — иначе каждый + * следующий тик снова просил бы перейти. + */ + private fun away(move: Move): Move { + entered = false + return move + } + + /** Тап по слайду (B1, B5): при открытой шторке он только закрывает её. */ + fun tap(zone: Zone): Move { + if (sheetOpen) { + setSheet(false) + return Move.CloseSheet + } + return when (zone) { + Zone.PREVIOUS -> previous() + Zone.NEXT -> next() + Zone.CENTER -> Move.None + } + } + + /** Системная «Назад»: сначала шторка, потом просмотр (B5). */ + fun back(): Move { + if (sheetOpen) { + setSheet(false) + return Move.CloseSheet + } + return Move.Close + } + + fun setSheet(open: Boolean) { + sheetOpen = open + setPaused(Pause.SHEET, open) + } + + /** Включить или снять причину паузы. Возвращает `true`, если изменилось, идут ли часы. */ + fun setPaused(reason: Pause, paused: Boolean): Boolean { + val before = isRunning to playerShouldPlay + if (paused) pauses.add(reason) else pauses.remove(reason) + return before != (isRunning to playerShouldPlay) + } + + /** Тик часов: прошло [deltaMs]. Время вышло — следующий слайд. */ + fun tick(deltaMs: Long): Move { + if (!isRunning || clock != Clock.TIMER || deltaMs <= 0) return Move.None + elapsedMs += deltaMs + if (elapsedMs < durationMs) return Move.None + elapsedMs = durationMs + return next() + } + + /** Позиция видео (C4): прогресс идёт за воспроизведением. */ + fun videoPosition(positionMs: Long) { + if (clock != Clock.PLAYER) return + elapsedMs = positionMs.coerceIn(0, durationMs) + } + + /** + * Медиа готово (C5): картинка декодирована, видео играет. [videoDurationMs] — длина + * ролика, если известна: слайд идёт по ней, а не по времени из админки (C4). + * [animationLoopMs] — проход GIF: слайд идёт по большему из него и админки (G2). + */ + fun mediaReady(videoDurationMs: Long? = null, animationLoopMs: Long? = null) { + if (videoDurationMs != null && videoDurationMs > 0) { + clock = Clock.PLAYER + durationMs = videoDurationMs + } else if (animationLoopMs != null) { + val serverMs = slide?.durationMs ?: StoriesMapping.DEFAULT_DURATION_MS + durationMs = StoriesMapping.animatedDurationMs(serverMs, animationLoopMs) + } + setPaused(Pause.ERROR, false) + setPaused(Pause.LOADING, false) + } + + /** Видео встало на подгрузку и снова пошло (C4). */ + fun buffering(active: Boolean) { + setPaused(Pause.LOADING, active) + } + + /** Медиа не загрузилось или не успело за 10 с (C5). */ + fun mediaFailed() { + setPaused(Pause.LOADING, false) + setPaused(Pause.ERROR, true) + } + + /** «Повторить»: слайд грузится заново с нуля. */ + fun retry() { + resetClock() + setPaused(Pause.ERROR, false) + setPaused(Pause.LOADING, true) + } + + /** Видео доиграло — слайд закончился (C4). */ + fun mediaEnded(): Move = if (entered) next() else Move.None + + val hasError: Boolean get() = Pause.ERROR in pauses + + /** Новый текущий слайд: шторка закрыта, время с нуля, медиа ещё грузится; он просмотрен. */ + private fun startSlide() { + resetSlide() + val shape = story ?: return + val current = slide ?: return + seen.markSeen(shape.id, current.id) + } + + private fun resetSlide() { + sheetOpen = false + pauses.remove(Pause.SHEET) + pauses.remove(Pause.ERROR) + pauses.add(Pause.LOADING) + resetClock() + } + + private fun resetClock() { + clock = Clock.TIMER + elapsedMs = 0 + durationMs = slide?.durationMs ?: StoriesMapping.DEFAULT_DURATION_MS + } + + companion object { + /** + * Зона тапа по трети ширины (B1): левая — назад, правая — вперёд, середина — ничего. + * В RTL края меняются местами. + */ + fun zone(x: Float, width: Int, rtl: Boolean): Zone { + if (width <= 0) return Zone.CENTER + val third = width / 3f + return when { + x < third -> if (rtl) Zone.NEXT else Zone.PREVIOUS + x > width - third -> if (rtl) Zone.PREVIOUS else Zone.NEXT + else -> Zone.CENTER + } + } + } +} diff --git a/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/StoriesViewerViews.kt b/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/StoriesViewerViews.kt new file mode 100644 index 00000000..a307a606 --- /dev/null +++ b/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/StoriesViewerViews.kt @@ -0,0 +1,331 @@ +package com.personalization.ui.widgets + +import android.annotation.SuppressLint +import android.app.Activity +import android.content.Context +import android.content.ContextWrapper +import android.os.Handler +import android.os.SystemClock +import android.view.Choreographer +import android.view.MotionEvent +import android.view.VelocityTracker +import android.view.View +import android.view.ViewConfiguration +import android.widget.FrameLayout +import androidx.lifecycle.LifecycleOwner +import com.personalization.R +import kotlin.math.abs + +/** Тексты блока сторис — одни имена на всех платформах (раздел D правил). */ +internal data class StoriesTexts( + val promoCaption: CharSequence, + val promoCopiedText: CharSequence, + val productButtonText: CharSequence, + val showProductsText: CharSequence, + val hideProductsText: CharSequence, + val retryText: CharSequence, + val closeLabel: CharSequence, + val soundOnLabel: CharSequence, + val soundOffLabel: CharSequence +) { + companion object { + /** Тексты по умолчанию — из ресурсов SDK (английские, с переводом в `values-ru`). */ + fun defaults(context: Context) = StoriesTexts( + promoCaption = context.getString(R.string.personalization_stories_promo_caption), + promoCopiedText = context.getString(R.string.personalization_stories_promo_copied), + productButtonText = context.getString(R.string.personalization_stories_product_button), + showProductsText = context.getString(R.string.personalization_stories_show_products), + hideProductsText = context.getString(R.string.personalization_stories_hide_products), + retryText = context.getString(R.string.personalization_stories_retry), + closeLabel = context.getString(R.string.personalization_stories_close), + soundOnLabel = context.getString(R.string.personalization_stories_sound_on), + soundOffLabel = context.getString(R.string.personalization_stories_sound_off) + ) + } +} + +internal fun Context.findActivity(): Activity? { + var current: Context? = this + while (current is ContextWrapper) { + if (current is Activity) return current + current = current.baseContext + } + return null +} + +internal fun Context.findLifecycleOwner(): LifecycleOwner? { + var current: Context? = this + while (current is ContextWrapper) { + if (current is LifecycleOwner) return current + current = current.baseContext + } + return null +} + +/** + * Часы слайда (B7): кадры [Choreographer], время — по меткам кадров. От масштаба анимаций + * системы они не зависят, в отличие от `ValueAnimator`: при «Отключить анимацию» слайды не + * пролетают. Шаг между кадрами ограничен — подвисший поток не перескакивает слайд. + */ +internal class StoryFrameClock(private val onTick: (deltaMs: Long) -> Unit) : Choreographer.FrameCallback { + + private var running = false + private var lastFrameNanos = 0L + + fun start() { + if (running) return + running = true + lastFrameNanos = 0L + Choreographer.getInstance().postFrameCallback(this) + } + + fun stop() { + if (!running) return + running = false + Choreographer.getInstance().removeFrameCallback(this) + } + + override fun doFrame(frameTimeNanos: Long) { + if (!running) return + val delta = if (lastFrameNanos == 0L) 0L else (frameTimeNanos - lastFrameNanos) / 1_000_000L + lastFrameNanos = frameTimeNanos + Choreographer.getInstance().postFrameCallback(this) + onTick(delta.coerceIn(0L, MAX_FRAME_MS)) + } + + private companion object { + const val MAX_FRAME_MS = 250L + } +} + +/** + * Отложенное действие просмотра: ожидание готовности медиа (10 с) и автоповтор видео (15 с). + * В фоне оно заморожено ([freeze]): время не идёт, а после возврата продолжается с остатка + * (F5) — пока приложение свёрнуто, слайд не успевает «не загрузиться». + */ +internal class StoryTimer(private val handler: Handler, private val action: () -> Unit) { + + /** Сколько осталось до срабатывания, мс; `null` — не заведён. */ + private var remainingMs: Long? = null + private var postedAt = 0L + private var frozen = false + private val runnable = Runnable { + remainingMs = null + action() + } + + val isScheduled: Boolean get() = remainingMs != null + + /** Завести заново на [delayMs]. В заморозке отсчёт начнётся после разморозки. */ + fun start(delayMs: Long) { + cancel() + remainingMs = delayMs + if (!frozen) post() + } + + fun cancel() { + handler.removeCallbacks(runnable) + remainingMs = null + } + + /** Заморозить отсчёт или продолжить его с остатка. */ + fun freeze(value: Boolean) { + if (frozen == value) return + frozen = value + val left = remainingMs ?: return + if (value) { + handler.removeCallbacks(runnable) + remainingMs = (left - (SystemClock.uptimeMillis() - postedAt)).coerceAtLeast(0L) + } else { + post() + } + } + + private fun post() { + val delay = remainingMs ?: return + postedAt = SystemClock.uptimeMillis() + handler.postDelayed(runnable, delay) + } +} + +/** + * Слой касаний слайда: тап по трети ширины (B1) и удержание (B2). Нажатие дольше 200 мс — + * пауза; отпускание её снимает и никуда не листает. Сдвинутый палец — не тап: его заберёт + * пейджер или свайп закрытия. + */ +@SuppressLint("ViewConstructor", "ClickableViewAccessibility") +internal class StoryTouchLayer( + context: Context, + private val onTap: (x: Float, width: Int, rtl: Boolean) -> Unit, + private val onHold: (Boolean) -> Unit +) : View(context) { + + private val touchSlop = ViewConfiguration.get(context).scaledTouchSlop + private var downX = 0f + private var downY = 0f + private var moved = false + private var holding = false + private val holdRunnable = Runnable { + holding = true + onHold(true) + } + + override fun onTouchEvent(event: MotionEvent): Boolean { + when (event.actionMasked) { + MotionEvent.ACTION_DOWN -> { + downX = event.x + downY = event.y + moved = false + postDelayed(holdRunnable, HOLD_MS) + } + MotionEvent.ACTION_MOVE -> + if (abs(event.x - downX) > touchSlop || abs(event.y - downY) > touchSlop) moved = true + MotionEvent.ACTION_UP -> { + removeCallbacks(holdRunnable) + if (holding) release() else if (!moved) onTap(event.x, width, layoutDirection == LAYOUT_DIRECTION_RTL) + } + MotionEvent.ACTION_CANCEL -> { + removeCallbacks(holdRunnable) + release() + } + } + return true + } + + override fun onDetachedFromWindow() { + removeCallbacks(holdRunnable) + release() + super.onDetachedFromWindow() + } + + private fun release() { + if (!holding) return + holding = false + onHold(false) + } + + private companion object { + const val HOLD_MS = 200L + } +} + +/** + * Корень просмотра: свайп вниз утаскивает сторис (B4). Закрывает, если протянуть дальше + * 120 dp или бросить быстрее 800 dp/с, иначе пружинит обратно. Пока тянут — пауза + * ([onDragChange]). При открытой шторке ([canDrag] = false) не тянется вовсе (B5). + * Горизонтальные жесты остаются пейджеру и карусели. + */ +@SuppressLint("ViewConstructor") +internal class StoryDismissLayout(context: Context) : FrameLayout(context) { + + var canDrag: () -> Boolean = { true } + var onDragChange: ((Boolean) -> Unit)? = null + var onDismiss: (() -> Unit)? = null + + private val touchSlop = ViewConfiguration.get(context).scaledTouchSlop + private val density = resources.displayMetrics.density + private var velocity: VelocityTracker? = null + private var downX = 0f + private var downY = 0f + private var dragging = false + + override fun onInterceptTouchEvent(event: MotionEvent): Boolean { + when (event.actionMasked) { + MotionEvent.ACTION_DOWN -> { + downX = event.rawX + downY = event.rawY + dragging = false + velocity?.recycle() + velocity = VelocityTracker.obtain() + track(event) + } + MotionEvent.ACTION_MOVE -> { + track(event) + val dy = event.rawY - downY + val dx = event.rawX - downX + if (canDrag() && dy > touchSlop && dy > abs(dx) * 1.5f) { + dragging = true + onDragChange?.invoke(true) + return true + } + } + } + return false + } + + @SuppressLint("ClickableViewAccessibility") + override fun onTouchEvent(event: MotionEvent): Boolean { + if (!dragging) return super.onTouchEvent(event) + track(event) + when (event.actionMasked) { + MotionEvent.ACTION_MOVE -> translationY = (event.rawY - downY).coerceAtLeast(0f) + MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> { + dragging = false + val tracker = velocity + tracker?.computeCurrentVelocity(1000) + val speedDp = (tracker?.yVelocity ?: 0f) / density + velocity?.recycle() + velocity = null + val far = translationY / density > DISMISS_DISTANCE_DP + val fast = event.actionMasked == MotionEvent.ACTION_UP && speedDp > DISMISS_VELOCITY_DP + if (far || fast) { + animate().translationY(height.toFloat()).setDuration(ANIMATION_MS) + .withEndAction { onDismiss?.invoke() }.start() + } else { + animate().translationY(0f).setDuration(ANIMATION_MS) + .withEndAction { onDragChange?.invoke(false) }.start() + } + } + } + return true + } + + /** Скорость — по координатам экрана: сама вьюха едет за пальцем. */ + private fun track(event: MotionEvent) { + val copy = MotionEvent.obtain(event) + copy.setLocation(event.rawX, event.rawY) + velocity?.addMovement(copy) + copy.recycle() + } + + private companion object { + const val DISMISS_DISTANCE_DP = 120f + const val DISMISS_VELOCITY_DP = 800f + const val ANIMATION_MS = 200L + } +} + +/** + * Обёртка карусели внутри пейджера: пока карусель может листаться в сторону жеста, + * родители (пейджер, свайп закрытия) жест не перехватывают. Схема NestedScrollableHost + * из примеров ViewPager2. + */ +@SuppressLint("ViewConstructor") +internal class StoryNestedScrollHost(context: Context, private val target: View) : FrameLayout(context) { + + private val touchSlop = ViewConfiguration.get(context).scaledTouchSlop + private var initialX = 0f + private var initialY = 0f + + override fun onInterceptTouchEvent(event: MotionEvent): Boolean { + if (target.canScrollHorizontally(1) || target.canScrollHorizontally(-1)) { + when (event.actionMasked) { + MotionEvent.ACTION_DOWN -> { + initialX = event.x + initialY = event.y + parent?.requestDisallowInterceptTouchEvent(true) + } + MotionEvent.ACTION_MOVE -> { + val dx = event.x - initialX + val dy = event.y - initialY + if (abs(dx) > touchSlop || abs(dy) > touchSlop) { + val horizontal = abs(dx) > abs(dy) + val canScroll = target.canScrollHorizontally(if (dx > 0) -1 else 1) + parent?.requestDisallowInterceptTouchEvent(horizontal && canScroll) + } + } + } + } + return super.onInterceptTouchEvent(event) + } +} diff --git a/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/StorySlideContent.kt b/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/StorySlideContent.kt new file mode 100644 index 00000000..21093b7b --- /dev/null +++ b/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/StorySlideContent.kt @@ -0,0 +1,83 @@ +package com.personalization.ui.widgets + +import android.content.ClipData +import android.content.ClipboardManager +import android.content.Context +import android.view.View +import android.widget.FrameLayout +import com.personalization.Product +import com.personalization.stories.models.Slide +import com.personalization.stories.models.elements.ProductElement +import com.personalization.ui.components.PersonalizationStoryCard +import com.personalization.ui.components.PersonalizationStoryTextBlock +import com.personalization.ui.components.PersonalizationToast + +/** + * Карточка товарного слайда (C8): бренд, название, фото, цена. Кнопки рисует слайд — + * все кнопки админки, а не одну кнопку карточки. Фото не нажимается (I1): тап по нему — + * тап по слайду, листание по зонам; товар открывают только кнопки (I2). + */ +internal object StoryProductCard { + + /** [slidePromo] — промокод текстового блока слайда, если у товара своего нет (H2). */ + fun build(context: Context, element: ProductElement, product: Product, host: StorySlideHost, slidePromo: String? = null): View { + val price = StoriesMapping.price(product, slidePromo) + return PersonalizationStoryCard(context).apply { + title = product.brand.takeIf { it.isNotEmpty() } + subtitle = product.name + if (product.image.isNotEmpty()) host.loadImage(imageView, product.image) + imageView.contentDescription = product.name + this.price.type = price.type + this.price.price = price.price + this.price.oldPrice = price.oldPrice + this.price.discount = price.discount + this.price.promoCode = price.promoCode + // Подпись над кодом — из админки, без неё — текст хоста (C9). + this.price.promoCaption = StoriesMapping.promoCaption(element, host.texts.promoCaption) + this.price.copiedText = host.texts.promoCopiedText + this.price.onPromoCopied = { host.onPromoCopied() } + buttonText = null + } + } +} + +/** + * Текстовые блоки медиа-слайда — на своей высоте (`y_offset`, проценты), как их расставила + * админка. Блок с промокодом по тапу копирует код и показывает «Copied» сверху (C12). + */ +internal object StoryTextBlocks { + + fun build(context: Context, slide: Slide, host: StorySlideHost): View { + val frame = FrameLayout(context) + StoriesMapping.textBlocks(slide).forEach { element -> + val block = PersonalizationStoryTextBlock(context).apply { + text = element.textInput + textSizeSp = element.fontSize.toFloat() + lineHeightSp = StoriesMapping.lineHeightSp(element) + blockColor = StoriesMapping.textBlockColor(element) + textColorOverride = StoriesMapping.parseColor(element.textColor) + align = StoriesMapping.textAlign(element) + bold = element.isBold + italic = element.isItalic + fontFamily = element.fontType.takeIf { it.isNotEmpty() } + } + StoriesMapping.textPromocode(element)?.let { code -> + block.setOnClickListener { copy(it, code, host) } + } + frame.addView(block, FrameLayout.LayoutParams(FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.WRAP_CONTENT)) + frame.post { + // Блок не уезжает за низ области: его должно быть видно целиком. + val top = frame.height * element.yOffset / 100f + block.y = top.coerceAtMost((frame.height - block.height).toFloat()).coerceAtLeast(0f) + } + } + return frame + } + + private fun copy(anchor: View, code: String, host: StorySlideHost) { + val clipboard = anchor.context.getSystemService(Context.CLIPBOARD_SERVICE) as? ClipboardManager + clipboard?.setPrimaryClip(ClipData.newPlainText(host.texts.promoCaption, code)) + PersonalizationToast.show(anchor, host.texts.promoCopiedText, PersonalizationToast.Position.TOP) + host.onPromoCopied() + } +} diff --git a/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/StorySlideView.kt b/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/StorySlideView.kt new file mode 100644 index 00000000..609b970c --- /dev/null +++ b/personalization-sdk/src/main/kotlin/com/personalization/ui/widgets/StorySlideView.kt @@ -0,0 +1,380 @@ +package com.personalization.ui.widgets + +import android.annotation.SuppressLint +import android.content.Context +import android.graphics.Color +import android.graphics.drawable.Drawable +import android.graphics.drawable.GradientDrawable +import android.view.Gravity +import android.view.MotionEvent +import android.view.View +import android.widget.FrameLayout +import android.widget.ImageView +import android.widget.LinearLayout +import androidx.appcompat.widget.AppCompatImageView +import androidx.core.graphics.Insets +import androidx.media3.common.util.UnstableApi +import androidx.media3.ui.AspectRatioFrameLayout +import androidx.media3.ui.PlayerView +import com.bumptech.glide.load.resource.gif.GifDrawable +import com.personalization.Product +import com.personalization.R +import com.personalization.stories.models.Slide +import com.personalization.stories.models.elements.ButtonElement +import com.personalization.ui.PersonalizationTheme +import com.personalization.ui.components.PersonalizationButton +import com.personalization.ui.components.PersonalizationStoryNavigation +import com.personalization.ui.components.PersonalizationStoryUsedProducts +import com.personalization.ui.components.StorySupport + +/** Что слайд просит у просмотра: загрузку картинок, навигацию, клики. */ +internal interface StorySlideHost { + val texts: StoriesTexts + val muted: Boolean + val sheetOpen: Boolean + val insets: Insets + /** Картинка компонента — товар, постер видео: GIF стоит на первом кадре (G6). */ + fun loadImage(view: ImageView, url: String, onReady: (() -> Unit)? = null, onFailed: (() -> Unit)? = null) + + /** + * Фон слайда — GIF здесь играет (G1). [onAnimation] зовётся до того, как картинка встанет + * во вьюху, и только для GIF, загруженного SDK: с проходом, мс, и самим GIF (G2, G5). + */ + fun loadSlideImage( + view: ImageView, + url: String, + onAnimation: (loopMs: Long?, gif: GifDrawable) -> Unit, + onReady: () -> Unit, + onFailed: () -> Unit + ) + + fun onTap(x: Float, width: Int, rtl: Boolean) + fun onHold(hold: Boolean) + fun onOutsideSheetTap() + fun onSheet(open: Boolean) + fun onButton(button: ButtonElement, product: Product?) + fun onProduct(product: Product) + fun onCarouselProduct(product: Product) + fun onPromoCopied() + fun onSoundToggle() + fun onRetry(view: StorySlideView) + fun onClose() +} + +/** + * Вёрстка одного слайда (Card/Story). Медиа-слайд строится в тёмном контексте (C1), + * слайд без медиа — в теме хоста на Background/Card (C2). Слои снизу вверх: поля вокруг + * медиа, фото/видео целиком (fit), скрим (C3), слой касаний, органы управления с отступами + * от системных панелей и выреза, кнопка «Повторить» (C5). Медиа идёт под панели, органы + * управления — нет. + */ +@androidx.annotation.OptIn(markerClass = [UnstableApi::class]) +@SuppressLint("ViewConstructor") +internal class StorySlideView( + baseContext: Context, + val storyIndex: Int, + val slideIndex: Int, + val slide: Slide, + slideCount: Int, + private val host: StorySlideHost +) : FrameLayout(if (StoriesMapping.isMedia(slide)) StorySupport.darkContext(baseContext) else baseContext) { + + enum class ImageState { LOADING, READY, FAILED } + + val isMedia = StoriesMapping.isMedia(slide) + val isVideo = StoriesMapping.isVideo(slide) + val navigation = PersonalizationStoryNavigation(context) + var playerView: PlayerView? = null + private set + + /** Медиа слайда уже запускали — повторный показ строит слайд заново. */ + var mediaStarted = false + + /** Медиа хоть раз было готово: дальше подгрузка — буферизация, а не загрузка. */ + var mediaReadyOnce = false + + var imageState = ImageState.LOADING + private set + + /** Картинка слайда загрузилась или нет. */ + var onImageState: (() -> Unit)? = null + + /** Проход GIF фона, мс; `null` — не GIF, проход не разобран или GIF грузил хост (G2, G8). */ + var animationLoopMs: Long? = null + private set + + /** GIF фона, которым управляет SDK: идёт вместе с часами слайда (G5). */ + private var animation: GifDrawable? = null + + /** Следующий запуск GIF — с первого кадра: слайд начался или начат заново (G5). */ + private var animationFromStart = true + + private val poster = StoryImageView(context) + private val column = LinearLayout(context) + private val retry = PersonalizationButton(context) + private var usedProducts: PersonalizationStoryUsedProducts? = null + private var usedHost: View? = null + private var sheetTapPending = false + private val padding = resources.getDimensionPixelSize(R.dimen.personalization_spacing_xl) + + init { + setBackgroundColor( + if (isMedia) StoriesMapping.letterboxColor(slide) + else PersonalizationTheme.color(context, R.color.personalization_background_card) + ) + if (isMedia) addMedia() + addView(View(context).apply { background = scrim(StoriesMapping.scrimAlpha(slide)) }, matchParent()) + addView(StoryTouchLayer(context, host::onTap, host::onHold), matchParent()) + + column.orientation = LinearLayout.VERTICAL + navigation.closeContentDescription = host.texts.closeLabel + navigation.onClose = { host.onClose() } + navigation.progress.count = slideCount + navigation.progress.current = slideIndex + // Навигация в том же отступе 16, что и контент слайда (Figma: content padding 16). + column.addView(navigation, columnParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT)) + buildContent() + addView(column, matchParent()) + + retry.text = host.texts.retryText + retry.buttonView = PersonalizationButton.ButtonView.PRIMARY + retry.visibility = View.GONE + retry.setOnClickListener { host.onRetry(this) } + addView(retry, LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT, Gravity.CENTER)) + applyInsets(host.insets) + } + + private fun addMedia() { + poster.scaleType = ImageView.ScaleType.FIT_CENTER + if (isVideo) { + playerView = PlayerView(context).apply { + useController = false + resizeMode = AspectRatioFrameLayout.RESIZE_MODE_FIT + setShutterBackgroundColor(Color.TRANSPARENT) + setBackgroundColor(Color.TRANSPARENT) + } + addView(playerView, matchParent()) + } + addView(poster, matchParent()) + loadImage() + } + + /** Картинка слайда или превью видео; у видео готовность решает плеер. */ + fun loadImage() { + val url = if (isVideo) slide.preview else slide.background + imageState = ImageState.LOADING + animation?.stop() + animation = null + animationLoopMs = null + if (url.isEmpty()) { + setImageState(if (isVideo) ImageState.READY else ImageState.FAILED) + return + } + poster.visibility = View.VISIBLE + poster.onDrawable = { setImageState(ImageState.READY) } + if (isVideo) { + host.loadImage(poster, url, { setImageState(ImageState.READY) }, { setImageState(ImageState.FAILED) }) + return + } + host.loadSlideImage( + poster, + url, + onAnimation = { loopMs, gif -> + animationLoopMs = loopMs + animation = gif + animationFromStart = true + }, + onReady = { setImageState(ImageState.READY) }, + onFailed = { setImageState(ImageState.FAILED) } + ) + } + + /** + * GIF фона идёт, только пока идут часы слайда (G5): пауза оставляет текущий кадр, + * продолжение — с него же, новый или начатый заново слайд — с первого кадра. + */ + fun setAnimationRunning(running: Boolean) { + val gif = animation ?: return + if (!running) { + if (gif.isRunning) gif.stop() + return + } + if (animationFromStart) { + animationFromStart = false + if (gif.isRunning) gif.stop() + gif.startFromFirstFrame() + } else if (!gif.isRunning) { + gif.start() + } + } + + /** Слайд начат заново (B3): GIF пойдёт с первого кадра, без новой загрузки (F3). */ + fun restartAnimation() { + animationFromStart = true + } + + /** Слайд ушёл с экрана — GIF стоит. */ + fun stopAnimation() { + animation?.stop() + animationFromStart = true + } + + private fun setImageState(state: ImageState) { + if (imageState == state) return + imageState = state + onImageState?.invoke() + } + + /** + * Товарный слайд (C8) — карточка товара, все кнопки слайда и строка товаров/звука; + * текстовые блоки на нём не рисуются. Медиа-слайд — текстовые блоки на своей высоте, + * кнопки и та же строка. + */ + private fun buildContent() { + val productElement = StoriesMapping.product(slide) + val product = productElement?.item + val middle: View = if (productElement != null && product != null) { + StoryProductCard.build(context, productElement, product, host, StoriesMapping.slidePromocode(slide)) + } else { + StoryTextBlocks.build(context, slide, host) + } + column.addView(middle, columnParams(LinearLayout.LayoutParams.MATCH_PARENT, 0, 1f)) + + val buttons = StoriesMapping.buttons(slide) + buttons.forEach { element -> addButton(element.title) { host.onButton(element, product) } } + // Без своих кнопок товар открывает кнопка хоста — «More info» (C11). + if (buttons.isEmpty() && product != null) addButton(host.texts.productButtonText) { host.onProduct(product) } + + val products = StoriesMapping.products(slide)?.let { element -> element to element.getProducts() } + if (products != null || isVideo) addUsedProducts(products?.first, products?.second.orEmpty()) + } + + private fun addButton(title: CharSequence, onClick: () -> Unit) { + val button = PersonalizationButton(context).apply { + size = PersonalizationButton.Size.LG + buttonView = PersonalizationButton.ButtonView.PRIMARY + text = title + setOnClickListener { onClick() } + } + column.addView(button, columnParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT)) + } + + private fun addUsedProducts( + element: com.personalization.stories.models.elements.ProductsElement?, + products: List + ) { + val used = PersonalizationStoryUsedProducts(context).apply { + this.products = products.map(StoriesMapping::cardProduct) + showText = element?.labelShow?.takeIf { it.isNotBlank() } ?: host.texts.showProductsText + hideText = element?.labelHide?.takeIf { it.isNotBlank() } ?: host.texts.hideProductsText + imageLoader = { view, item -> item.imageUrl?.let { host.loadImage(view, it) } } + onProductClick = { item -> products.firstOrNull { it.id == item.id }?.let(host::onCarouselProduct) } + onExpandedChange = { open -> host.onSheet(open) } + showSoundButton = isVideo + soundOnDescription = host.texts.soundOnLabel + soundOffDescription = host.texts.soundOffLabel + muted = host.muted + onSoundClick = { host.onSoundToggle() } + } + usedProducts = used + val wrapper = StoryNestedScrollHost(context, used.carousel) + wrapper.addView(used, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT)) + usedHost = wrapper + column.addView(wrapper, LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT)) + } + + private fun columnParams(width: Int, height: Int, weight: Float = 0f) = + LinearLayout.LayoutParams(width, height, weight).apply { + marginStart = padding + marginEnd = padding + topMargin = padding + } + + /** + * Отступы от системных панелей и выреза — только у органов управления (дефект + * edge-to-edge). Шторка товаров уходит под панель навигации своим фоном. + */ + fun applyInsets(insets: Insets) { + val used = usedHost + column.setPadding(insets.left, insets.top, insets.right, if (used == null) insets.bottom + padding else 0) + used?.setPadding(0, 0, 0, insets.bottom) + } + + fun setProgress(progress: Float) { + navigation.progress.progress = progress + } + + fun setMuted(muted: Boolean) { + usedProducts?.muted = muted + } + + fun closeSheet() { + usedProducts?.expanded = false + } + + fun hidePoster() { + if (isVideo) poster.visibility = View.GONE + } + + fun showRetry(show: Boolean) { + retry.visibility = if (show) View.VISIBLE else View.GONE + } + + /** + * При открытой шторке тап мимо неё только закрывает её (B5). Крестик не в счёт: он + * закрывает просмотр всегда, и при открытой шторке тоже (F2). + */ + override fun onInterceptTouchEvent(event: MotionEvent): Boolean { + if (event.actionMasked == MotionEvent.ACTION_DOWN && host.sheetOpen && + !inside(usedHost, event) && !inside(navigation.closeButton, event) + ) { + sheetTapPending = true + return true + } + return false + } + + @SuppressLint("ClickableViewAccessibility") + override fun onTouchEvent(event: MotionEvent): Boolean { + if (!sheetTapPending) return super.onTouchEvent(event) + when (event.actionMasked) { + MotionEvent.ACTION_UP -> { + sheetTapPending = false + host.onOutsideSheetTap() + } + MotionEvent.ACTION_CANCEL -> sheetTapPending = false + } + return true + } + + private fun inside(view: View?, event: MotionEvent): Boolean { + view ?: return false + val location = IntArray(2) + view.getLocationOnScreen(location) + return event.rawX >= location[0] && event.rawX <= location[0] + view.width && + event.rawY >= location[1] && event.rawY <= location[1] + view.height + } + + private fun matchParent() = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT) + + private fun scrim(alpha: Int): GradientDrawable { + val dark = Color.argb(alpha, 0, 0, 0) + return GradientDrawable( + GradientDrawable.Orientation.TOP_BOTTOM, + intArrayOf(dark, Color.TRANSPARENT, Color.TRANSPARENT, Color.TRANSPARENT, Color.TRANSPARENT, dark) + ) + } +} + +/** + * Картинка, которая сообщает, что ей поставили изображение: так готовность видна и при + * загрузчике хоста, который о себе ничего не сообщает. + */ +internal class StoryImageView(context: Context) : AppCompatImageView(context) { + var onDrawable: (() -> Unit)? = null + + override fun setImageDrawable(drawable: Drawable?) { + super.setImageDrawable(drawable) + if (drawable != null) onDrawable?.invoke() + } +} diff --git a/personalization-sdk/src/main/res/drawable/personalization_ic_speaker.xml b/personalization-sdk/src/main/res/drawable/personalization_ic_speaker.xml new file mode 100644 index 00000000..afc2c637 --- /dev/null +++ b/personalization-sdk/src/main/res/drawable/personalization_ic_speaker.xml @@ -0,0 +1,30 @@ + + + + + + + + + + diff --git a/personalization-sdk/src/main/res/drawable/personalization_ic_speaker_off.xml b/personalization-sdk/src/main/res/drawable/personalization_ic_speaker_off.xml new file mode 100644 index 00000000..160da80d --- /dev/null +++ b/personalization-sdk/src/main/res/drawable/personalization_ic_speaker_off.xml @@ -0,0 +1,28 @@ + + + + + + + + + diff --git a/personalization-sdk/src/main/res/values-night/personalization_colors.xml b/personalization-sdk/src/main/res/values-night/personalization_colors.xml index 637ac9bb..be4a3819 100644 --- a/personalization-sdk/src/main/res/values-night/personalization_colors.xml +++ b/personalization-sdk/src/main/res/values-night/personalization_colors.xml @@ -14,10 +14,13 @@ #0DFFFFFF + #1AFFFFFF #FFE51919 #FFF37A17 + #FF0087E8 + #FF262626 #FF0D0D0D diff --git a/personalization-sdk/src/main/res/values-ru/strings.xml b/personalization-sdk/src/main/res/values-ru/strings.xml index cac0144c..db5ab33c 100644 --- a/personalization-sdk/src/main/res/values-ru/strings.xml +++ b/personalization-sdk/src/main/res/values-ru/strings.xml @@ -14,4 +14,15 @@ Invalid notification data. Notifications are already enabled - \ No newline at end of file + + Промокод + Скопировано + Подробнее + Используемые товары + Скрыть товары + Повторить + Закрыть + Звук включён + Звук выключен + + diff --git a/personalization-sdk/src/main/res/values/personalization_attrs.xml b/personalization-sdk/src/main/res/values/personalization_attrs.xml index 47034a5b..aa6a1a68 100644 --- a/personalization-sdk/src/main/res/values/personalization_attrs.xml +++ b/personalization-sdk/src/main/res/values/personalization_attrs.xml @@ -16,6 +16,9 @@ + + + @@ -83,5 +86,10 @@ + + + + + diff --git a/personalization-sdk/src/main/res/values/personalization_colors.xml b/personalization-sdk/src/main/res/values/personalization_colors.xml index 1091c741..bcaba043 100644 --- a/personalization-sdk/src/main/res/values/personalization_colors.xml +++ b/personalization-sdk/src/main/res/values/personalization_colors.xml @@ -14,10 +14,15 @@ #0D000000 + + #1A000000 #FFF37A17 #FFE51919 + #FF0087E8 + + #FFCCCCCC #FFF2F2F2 diff --git a/personalization-sdk/src/main/res/values/personalization_theme.xml b/personalization-sdk/src/main/res/values/personalization_theme.xml index 4939fc30..f6e6d871 100644 --- a/personalization-sdk/src/main/res/values/personalization_theme.xml +++ b/personalization-sdk/src/main/res/values/personalization_theme.xml @@ -14,6 +14,9 @@ @color/personalization_neutral_50 @color/personalization_semantic_warning @color/personalization_semantic_danger + @color/personalization_neutral_100 + @color/personalization_semantic_info + @color/personalization_semantic_neutral_subtle @color/personalization_background_generic @color/personalization_background_card @color/personalization_background_input diff --git a/personalization-sdk/src/main/res/values/strings.xml b/personalization-sdk/src/main/res/values/strings.xml index 441ddf8b..4fc649fa 100644 --- a/personalization-sdk/src/main/res/values/strings.xml +++ b/personalization-sdk/src/main/res/values/strings.xml @@ -26,4 +26,15 @@ Invalid notification data. Notifications are already enabled + + Promo code + Copied + More info + Used products + Hide products + Retry + Close + Sound on + Sound off + diff --git a/personalization-sdk/src/test/kotlin/com/personalization/ui/components/PersonalizationStoryComponentsTest.kt b/personalization-sdk/src/test/kotlin/com/personalization/ui/components/PersonalizationStoryComponentsTest.kt new file mode 100644 index 00000000..049042db --- /dev/null +++ b/personalization-sdk/src/test/kotlin/com/personalization/ui/components/PersonalizationStoryComponentsTest.kt @@ -0,0 +1,194 @@ +package com.personalization.ui.components + +import android.app.Activity +import android.content.ClipboardManager +import android.content.Context +import android.graphics.Color +import android.view.View +import android.view.ViewGroup +import android.widget.ImageView +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.Robolectric +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +/** Stories V2 building blocks: price text, countdown, text block frame, promo copy. */ +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28]) +class PersonalizationStoryComponentsTest { + + private val activity = Robolectric.buildActivity(Activity::class.java).setup().get() + + @Test + fun `the currency is split off a formatted price`() { + assertEquals(PersonalizationStoryAmount("1 190 900", "₽"), PersonalizationStoryAmount.parse("1 190 900 ₽")) + assertEquals(PersonalizationStoryAmount("19 990", "₸"), PersonalizationStoryAmount.parse(" 19 990 ₸ ")) + // A trailing token with digits is not a currency. + assertEquals(PersonalizationStoryAmount("1 190 900", null), PersonalizationStoryAmount.parse("1 190 900")) + assertEquals(PersonalizationStoryAmount("$99", null), PersonalizationStoryAmount.parse("$99")) + } + + @Test + fun `the countdown is split into days, hours, minutes and seconds`() { + val remaining = ((2 * 24 + 18) * 3600L + 33 * 60 + 24) * 1000 + assertEquals(PersonalizationStoryTimerParts(2, 18, 33, 24), PersonalizationStoryTimerParts.of(remaining)) + // The last second still shows 1, not 0. + assertEquals(PersonalizationStoryTimerParts(0, 0, 0, 1), PersonalizationStoryTimerParts.of(400)) + assertEquals(PersonalizationStoryTimerParts(0, 0, 0, 0), PersonalizationStoryTimerParts.of(-5000)) + } + + @Test + fun `the timer shows the remaining time and reports the end`() { + var now = 1_000_000L + var finished = 0 + val timer = PersonalizationStoryTimer(activity).apply { + clock = { now } + onFinished = { finished++ } + endTimeMillis = now + 65_000 + } + assertEquals("0 d", unitText(timer, 0)) + assertEquals("00 h", unitText(timer, 1)) + assertEquals("01 m", unitText(timer, 2)) + assertEquals("05 s", unitText(timer, 3)) + + now += 70_000 + timer.endTimeMillis = timer.endTimeMillis + assertEquals("00 s", unitText(timer, 3)) + assertEquals(1, finished) + } + + @Test + fun `a solid text block gets the kit frame, a transparent one none`() { + val block = PersonalizationStoryTextBlock(activity).apply { + size = PersonalizationStoryTextBlock.Size.LARGE + blockColor = Color.BLUE + } + assertEquals(dp(16), block.paddingLeft) + assertEquals(dp(12), block.paddingTop) + + // Medium (30) keeps the small padding: only text bigger than Medium gets 12. + block.size = PersonalizationStoryTextBlock.Size.MEDIUM + assertEquals(dp(8), block.paddingTop) + block.textSizeSp = 36f + assertEquals(dp(12), block.paddingTop) + + block.blockColor = null + assertEquals(0, block.paddingLeft) + assertNull(block.background) + } + + @Test + fun `the price shows only the block of its type`() { + val price = PersonalizationStoryPrice(activity).apply { + price = "1 190 900 ₽" + oldPrice = "245 000 ₽" + discount = "10%" + promoCode = "PROMO" + } + val (discount, promo) = rightBlocks(price) + + price.type = PersonalizationStoryPrice.Type.PRICE + assertEquals(View.GONE, discount.visibility) + assertEquals(View.GONE, promo.visibility) + + price.type = PersonalizationStoryPrice.Type.DISCOUNT + assertEquals(View.VISIBLE, discount.visibility) + assertEquals(View.GONE, promo.visibility) + + price.type = PersonalizationStoryPrice.Type.PROMO_CODE + assertEquals(View.GONE, discount.visibility) + assertEquals(View.VISIBLE, promo.visibility) + } + + @Test + fun `without an old price the row is tall enough for the promo caption and code`() { + val price = PersonalizationStoryPrice(activity).apply { + type = PersonalizationStoryPrice.Type.PROMO_CODE + this.price = "7 490 ₽" + promoCode = "SOUND10" + } + price.measure( + View.MeasureSpec.makeMeasureSpec(dp(370), View.MeasureSpec.EXACTLY), + View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED) + ) + price.layout(0, 0, price.measuredWidth, price.measuredHeight) + + val promo = rightBlocks(price).second as ViewGroup + val column = promo.getChildAt(0) + // Measured inside the box the column is clamped to it; ask what it needs unclamped. + column.measure( + View.MeasureSpec.makeMeasureSpec(column.width, View.MeasureSpec.EXACTLY), + View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED) + ) + assertTrue( + "promo column ${column.measuredHeight} must fit the box ${promo.height}", + column.measuredHeight <= promo.height + ) + } + + @Test + fun `tapping the promo code copies it and reports`() { + val content: ViewGroup = activity.findViewById(android.R.id.content) + var copied: String? = null + val price = PersonalizationStoryPrice(activity).apply { + type = PersonalizationStoryPrice.Type.PROMO_CODE + this.price = "990 ₽" + promoCode = "YAGODA-MALINA" + onPromoCopied = { copied = it } + } + content.addView(price) + + rightBlocks(price).second.performClick() + + assertEquals("YAGODA-MALINA", copied) + val clipboard = activity.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager + assertEquals("YAGODA-MALINA", clipboard.primaryClip?.getItemAt(0)?.text?.toString()) + assertTrue((0 until content.childCount).any { content.getChildAt(it) is PersonalizationToast }) + } + + @Test + fun `a pinned cover shows the star, others do not`() { + val cover = PersonalizationStoryCover(activity) + val star = cover.getChildAt(1) + + cover.state = PersonalizationStoryCover.State.PINNED + assertEquals(View.VISIBLE, star.visibility) + + cover.state = PersonalizationStoryCover.State.VIEWED + assertEquals(View.GONE, star.visibility) + } + + @Test + fun `the sound button names the current sound state and is selected while the sound is on`() { + val used = PersonalizationStoryUsedProducts(activity).apply { + showSoundButton = true + muted = true + } + val sound = firstImage(used) { it.contentDescription == "Sound off" }!! + assertFalse(sound.isSelected) + + used.muted = false + assertEquals("Sound on", sound.contentDescription) + assertTrue(sound.isSelected) + } + + private fun firstImage(view: View, matches: (ImageView) -> Boolean): ImageView? { + if (view is ImageView && matches(view)) return view + if (view !is ViewGroup) return null + for (index in 0 until view.childCount) firstImage(view.getChildAt(index), matches)?.let { return it } + return null + } + + private fun rightBlocks(price: PersonalizationStoryPrice): Pair = + price.getChildAt(1) to price.getChildAt(2) + + private fun unitText(timer: PersonalizationStoryTimer, index: Int): String = + (timer.getChildAt(index) as android.widget.TextView).text.toString().replace(' ', ' ') + + private fun dp(value: Int): Int = (value * activity.resources.displayMetrics.density).toInt() +} diff --git a/personalization-sdk/src/test/kotlin/com/personalization/ui/widgets/PersonalizationStoriesTest.kt b/personalization-sdk/src/test/kotlin/com/personalization/ui/widgets/PersonalizationStoriesTest.kt new file mode 100644 index 00000000..bdbf7a12 --- /dev/null +++ b/personalization-sdk/src/test/kotlin/com/personalization/ui/widgets/PersonalizationStoriesTest.kt @@ -0,0 +1,193 @@ +package com.personalization.ui.widgets + +import android.app.Activity +import android.os.Looper +import android.view.View +import android.view.ViewGroup +import androidx.viewpager2.widget.ViewPager2 +import com.personalization.SDK +import com.personalization.api.OnApiCallbackListener +import com.personalization.stories.StoriesManager +import io.mockk.every +import io.mockk.mockk +import org.json.JSONArray +import org.json.JSONObject +import org.junit.Assert.assertEquals +import org.junit.Assert.assertSame +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.Robolectric +import org.robolectric.RobolectricTestRunner +import org.robolectric.Shadows.shadowOf +import org.robolectric.annotation.Config +import org.robolectric.shadows.ShadowDialog + +/** The widget's programmatic control (open, open by id, pause, resume) and show() without the bar. */ +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28]) +class PersonalizationStoriesTest { + + private val activity = Robolectric.buildActivity(Activity::class.java).setup().get() + private lateinit var sdk: SDK + private var served = listOf(11, 12, 13) + + @Before + fun setUp() { + val manager = mockk(relaxed = true) + every { manager.requestStories(any(), any()) } answers { + secondArg().onSuccess(block(served)) + } + sdk = mockk(relaxed = true) + every { sdk.storiesManager } returns manager + } + + @Test + fun `open while the viewer is open pages inside that viewer`() { + val widget = widget() + widget.open(0) + idle() + val viewer = ShadowDialog.getLatestDialog() as PersonalizationStoriesViewer + assertEquals(0, pager(viewer).currentItem) + + widget.open(2) + idle() + assertSame(viewer, ShadowDialog.getLatestDialog()) + assertTrue(viewer.isShowing) + assertEquals(1, ShadowDialog.getShownDialogs().size) + assertEquals(2, pager(viewer).currentItem) + + widget.openStory(12) + idle() + assertEquals(1, pager(viewer).currentItem) + assertEquals(1, ShadowDialog.getShownDialogs().size) + } + + @Test + fun `pause and resume without an open viewer do nothing`() { + val widget = widget() + widget.pause() + widget.resume() + idle() + assertEquals(0, ShadowDialog.getShownDialogs().size) + } + + @Test + fun `a story opens by its id as a string, a non-number opens nothing`() { + val widget = widget() + widget.openStory("x") + idle() + assertEquals(0, ShadowDialog.getShownDialogs().size) + + widget.openStory(" 13 ") + idle() + assertEquals(2, pager(ShadowDialog.getLatestDialog() as PersonalizationStoriesViewer).currentItem) + } + + @Test + fun `the compose controller keeps an open call until the widget shows`() { + val controller = PersonalizationStoriesController() + controller.openStory("12") + controller.pause() + + controller.view = widget() + idle() + assertEquals(1, pager(ShadowDialog.getLatestDialog() as PersonalizationStoriesViewer).currentItem) + } + + @Test + fun `show reports the viewer closing`() { + var closed = 0 + var errors = 0 + show(startStoryId = 12, onError = { errors++ }, onClose = { closed++ }) + val viewer = ShadowDialog.getLatestDialog() as PersonalizationStoriesViewer + assertEquals(1, pager(viewer).currentItem) + assertEquals(0, closed) + + viewer.dismiss() + idle() + assertEquals(1, closed) + assertEquals(0, errors) + } + + @Test + fun `show with an unknown start story opens the first one`() { + show(startStoryId = 99) + assertEquals(0, pager(ShadowDialog.getLatestDialog() as PersonalizationStoriesViewer).currentItem) + } + + @Test + fun `show of an empty block reports the error and opens nothing`() { + served = emptyList() + var closed = 0 + var errors = 0 + show(onError = { errors++ }, onClose = { closed++ }) + + assertEquals(1, errors) + assertEquals(0, closed) + assertEquals(0, ShadowDialog.getShownDialogs().size) + } + + @Test + fun `a repeated story id is dropped, the first story stays`() { + val stories = StoriesLoader.parse(block(listOf(7, 8, 7))) + + assertEquals(listOf(7, 8), stories.map { it.id }) + } + + private fun show(startStoryId: Int? = null, onError: () -> Unit = {}, onClose: () -> Unit = {}) { + PersonalizationStories.show( + context = activity, + code = "BLOCK", + sdk = sdk, + startStoryId = startStoryId, + onError = { _, _ -> onError() }, + onClose = onClose, + imageLoader = { _, _ -> } + ) + idle() + } + + /** Photo slides whose loader never answers: the slide clock stands, nothing pages by itself. */ + private fun widget() = PersonalizationStories(activity).apply { + code = "BLOCK" + imageLoader = { _, _ -> } + attach(sdk) + } + + private fun pager(viewer: PersonalizationStoriesViewer): ViewPager2 = + find(viewer.window!!.decorView, ViewPager2::class.java)!! + + private fun find(view: View, type: Class): T? { + if (type.isInstance(view)) return type.cast(view) + if (view !is ViewGroup) return null + for (index in 0 until view.childCount) find(view.getChildAt(index), type)?.let { return it } + return null + } + + private fun idle() = shadowOf(Looper.getMainLooper()).idle() + + private fun block(ids: List) = JSONObject().put( + "stories", + JSONArray().apply { + ids.forEach { id -> + put( + JSONObject() + .put("id", id) + .put("name", "Story $id") + .put( + "slides", + JSONArray().put( + JSONObject() + .put("id", "${id}1") + .put("type", "image") + .put("background", "https://example.com/$id.jpg") + .put("elements", JSONArray()) + ) + ) + ) + } + } + ) +} diff --git a/personalization-sdk/src/test/kotlin/com/personalization/ui/widgets/StoriesGifTest.kt b/personalization-sdk/src/test/kotlin/com/personalization/ui/widgets/StoriesGifTest.kt new file mode 100644 index 00000000..e2af7d0f --- /dev/null +++ b/personalization-sdk/src/test/kotlin/com/personalization/ui/widgets/StoriesGifTest.kt @@ -0,0 +1,56 @@ +package com.personalization.ui.widgets + +import java.nio.ByteBuffer +import java.util.Base64 +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Test + +/** GIF loop length (rules G1, G2) on the fixture shared by all four SDKs. */ +class StoriesGifTest { + + /** 2x2, 3 frames, delays 10 cs / 0 cs / 50 cs, loops forever. */ + private val fixture = Base64.getDecoder().decode( + "R0lGODlhAgACAIEAAP8AAAD/AAAA/////yH/C05FVFNDQVBFMi4wAwEAAAAh+QQACgAAACwAAAAAAgACAAACAoRRACH5BAAAAAAALAAA" + + "AAACAAIAAAICjFMAIfkEADIAAAAsAAAAAAIAAgAAAgKUVQA7" + ) + + @Test + fun `a gif is recognised by its signature`() { + assertTrue(StoriesGif.isGif(ByteBuffer.wrap(fixture))) + assertTrue(StoriesGif.isGif(ByteBuffer.wrap("GIF87a....".toByteArray()))) + val png = byteArrayOf(0x89.toByte(), 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A) + assertFalse(StoriesGif.isGif(ByteBuffer.wrap(png))) + assertFalse(StoriesGif.isGif(ByteBuffer.wrap(ByteArray(3)))) + } + + @Test + fun `frame delays below 20 ms count as 100 ms`() { + assertEquals(listOf(100L, 100L, 500L), StoriesGif.frameDelaysMs(ByteBuffer.wrap(fixture))) + assertEquals(700L, StoriesGif.loopMs(ByteBuffer.wrap(fixture))) + } + + @Test + fun `the buffer position does not matter and is left alone`() { + val buffer = ByteBuffer.wrap(fixture) + buffer.position(20) + assertEquals(700L, StoriesGif.loopMs(buffer)) + assertEquals(20, buffer.position()) + } + + @Test + fun `not a gif or a broken gif has no loop`() { + assertNull(StoriesGif.loopMs(ByteBuffer.wrap("not a gif".toByteArray()))) + assertNull(StoriesGif.loopMs(ByteBuffer.wrap(fixture.copyOf(30)))) + } + + @Test + fun `the slide length is the longer of the loop and the admin duration`() { + assertEquals(8000L, StoriesMapping.animatedDurationMs(5000, 8000)) + assertEquals(5000L, StoriesMapping.animatedDurationMs(5000, 700)) + assertEquals(5000L, StoriesMapping.animatedDurationMs(5000, null)) + assertEquals(5000L, StoriesMapping.animatedDurationMs(5000, 0)) + } +} diff --git a/personalization-sdk/src/test/kotlin/com/personalization/ui/widgets/StoriesMappingTest.kt b/personalization-sdk/src/test/kotlin/com/personalization/ui/widgets/StoriesMappingTest.kt new file mode 100644 index 00000000..a0282932 --- /dev/null +++ b/personalization-sdk/src/test/kotlin/com/personalization/ui/widgets/StoriesMappingTest.kt @@ -0,0 +1,453 @@ +package com.personalization.ui.widgets + +import android.content.Context +import android.graphics.Color +import androidx.test.core.app.ApplicationProvider +import com.personalization.Product +import com.personalization.stories.models.Slide +import com.personalization.stories.models.Story +import com.personalization.stories.models.elements.ButtonElement +import com.personalization.stories.models.elements.ProductElement +import com.personalization.stories.models.elements.TextBlockElement +import com.personalization.ui.components.PersonalizationStoryCover +import com.personalization.ui.components.PersonalizationStoryPrice +import com.personalization.ui.components.PersonalizationStoryTextBlock +import java.math.BigDecimal +import org.json.JSONArray +import org.json.JSONObject +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +/** Stories block data → kit components, on the shapes the stories endpoint returns. */ +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28]) +class StoriesMappingTest { + + // --- Price (C10) ---------------------------------------------------------------------------- + + @Test + fun `a promo code beats the discount and crosses out the regular price`() { + val price = StoriesMapping.price( + product( + "price" to 1000, "price_formatted" to "1 000 ₽", + "discount_percent" to 10, + "promocode" to "PROMO", "price_with_promocode_formatted" to "900 ₽" + ) + ) + assertEquals(PersonalizationStoryPrice.Type.PROMO_CODE, price.type) + assertEquals("900 ₽", price.price) + assertEquals("1 000 ₽", price.oldPrice) + assertEquals("PROMO", price.promoCode) + } + + @Test + fun `a promo code crosses out the old price when there is one`() { + val price = StoriesMapping.price( + product( + "price" to 1000, "price_formatted" to "1 000 ₽", + "oldprice" to 1500, "oldprice_formatted" to "1 500 ₽", + "promocode" to "PROMO", "price_with_promocode_formatted" to "900 ₽" + ) + ) + assertEquals("1 500 ₽", price.oldPrice) + } + + @Test + fun `under a promo code an old price counts only above the regular price`() { + // 950 is above the promo price but below the regular one: the regular price is crossed out. + val belowRegular = StoriesMapping.price( + product( + "price" to 1000, "price_formatted" to "1 000 ₽", + "oldprice" to 950, "oldprice_formatted" to "950 ₽", + "promocode" to "PROMO", "price_with_promocode" to 900, "price_with_promocode_formatted" to "900 ₽" + ) + ) + assertEquals("1 000 ₽", belowRegular.oldPrice) + // An old price equal to the regular one is no markdown either. + val equalToRegular = StoriesMapping.price( + product( + "price" to 1000, "price_formatted" to "1 000 ₽", + "oldprice" to 1000, "oldprice_formatted" to "1 000.00 ₽", + "promocode" to "PROMO", "price_with_promocode_formatted" to "900 ₽" + ) + ) + assertEquals("1 000 ₽", equalToRegular.oldPrice) + } + + @Test + fun `under a promo code the regular price is crossed out only when it is above the promo price`() { + val same = StoriesMapping.price( + product( + "price" to 1000, "price_formatted" to "1 000 ₽", + "promocode" to "PROMO", "price_with_promocode" to "1000.00", "price_with_promocode_formatted" to "1 000 ₽" + ) + ) + assertNull(same.oldPrice) + val higherPromo = StoriesMapping.price( + product( + "price" to 1000, "price_formatted" to "1 000 ₽", + "promocode" to "PROMO", "price_with_promocode_formatted" to "1 100 ₽" + ) + ) + assertNull(higherPromo.oldPrice) + } + + @Test + fun `a promo code without a promo price shows the regular price and crosses nothing`() { + val price = StoriesMapping.price( + product("price" to 1000, "price_formatted" to "1 000 ₽", "promocode" to "PROMO") + ) + assertEquals("1 000 ₽", price.price) + assertNull(price.oldPrice) + } + + @Test + fun `a discount percent shows the discount block with the old price`() { + val price = StoriesMapping.price( + product( + "price" to 19990, "price_formatted" to "19 990 ₽", + "oldprice" to 27990, "oldprice_formatted" to "27 990 ₽", + "discount_percent" to 28 + ) + ) + assertEquals(PersonalizationStoryPrice.Type.DISCOUNT, price.type) + assertEquals("28%", price.discount) + assertEquals("27 990 ₽", price.oldPrice) + } + + @Test + fun `a fractional discount keeps its fraction`() { + val price = StoriesMapping.price(product("price" to 100, "price_formatted" to "100 ₽", "discount_percent" to 12.5)) + assertEquals("12.5%", price.discount) + } + + @Test + fun `an old price equal to the price is not shown`() { + // The endpoint sends oldprice == price for goods without a markdown. + val price = StoriesMapping.price( + product( + "price" to 14990, "price_formatted" to "14 990 ₽", + "oldprice" to 14990, "oldprice_formatted" to "14 990 ₽" + ) + ) + assertEquals(PersonalizationStoryPrice.Type.PRICE, price.type) + assertNull(price.oldPrice) + } + + @Test + fun `an old price lower than the price is not shown, compared as decimals`() { + val lower = StoriesMapping.price( + product( + "price" to 99.99, "price_formatted" to "99,99 €", + "oldprice" to 99.5, "oldprice_formatted" to "99,50 €" + ) + ) + assertNull(lower.oldPrice) + // 99.99 > 99.5 only as a decimal: as Ints both are 99. + val higher = StoriesMapping.price( + product( + "price" to 99.5, "price_formatted" to "99,50 €", + "oldprice" to 99.99, "oldprice_formatted" to "99,99 €" + ) + ) + assertEquals("99,99 €", higher.oldPrice) + } + + @Test + fun `formatted prices parse as decimals`() { + assertEquals(BigDecimal("1190900"), Decimals.parse("1 190 900 ₽")) + assertEquals(BigDecimal("19.99"), Decimals.parse("19,99 €")) + assertEquals(BigDecimal("1190.50"), Decimals.parse("$1,190.50")) + assertEquals(BigDecimal("1190"), Decimals.parse("1,190 ₸")) + assertNull(Decimals.parse("₽")) + assertNull(Decimals.parse("")) + } + + @Test + fun `a carousel product gets a signed discount only with a real markdown`() { + val card = StoriesMapping.cardProduct( + product( + "id" to "1", "name" to "Mouse", "price" to 100, "price_formatted" to "100 ₽", + "oldprice" to 150, "oldprice_formatted" to "150 ₽", "discount" to 33 + ) + ) + assertEquals("-33%", card.discount) + assertEquals("150 ₽", card.oldPrice) + + val same = StoriesMapping.cardProduct( + product("price" to 100, "price_formatted" to "100 ₽", "oldprice" to 100, "oldprice_formatted" to "100 ₽") + ) + assertNull(same.oldPrice) + } + + // --- Seen, start slide and ring (A3, A4, A5) ------------------------------------------------ + + @Test + fun `a story is viewed when the server says so or every slide is seen`() { + val story = story(slides = 2) + assertFalse(StoriesMapping.isViewed(story, setOf("s0"))) + assertTrue(StoriesMapping.isViewed(story, setOf("s0", "s1"))) + assertTrue(StoriesMapping.isViewed(story(viewed = true), emptySet())) + } + + @Test + fun `the start slide is the first unseen, the server position, or the start`() { + assertEquals(2, StoriesMapping.startSlide(story(startPosition = 2, slides = 5), emptySet())) + assertEquals(1, StoriesMapping.startSlide(story(startPosition = 3, slides = 5), setOf("s0", "s2"))) + assertEquals(0, StoriesMapping.startSlide(story(viewed = true, startPosition = 2, slides = 5), emptySet())) + assertEquals(0, StoriesMapping.startSlide(story(slides = 2), setOf("s0", "s1"))) + assertEquals(4, StoriesMapping.startSlide(story(startPosition = 9, slides = 5), emptySet())) + } + + @Test + fun `the ring lights seen slides by index`() { + val item = StoriesMapping.item(story(startPosition = 2, slides = 5), setOf("s1", "s3")) + assertEquals(PersonalizationStoryCover.State.DEFAULT, item.state) + assertEquals(5, item.segments) + assertEquals(setOf(1, 3), item.seenSegments) + } + + @Test + fun `a viewed story has a plain ring, a pinned one stays pinned`() { + val viewed = StoriesMapping.item(story(slides = 3), setOf("s0", "s1", "s2")) + assertEquals(PersonalizationStoryCover.State.VIEWED, viewed.state) + assertEquals(1, viewed.segments) + assertTrue(viewed.seenSegments.isEmpty()) + + val pinnedViewed = StoriesMapping.item(story(pinned = true, viewed = true, slides = 3), emptySet()) + assertEquals(PersonalizationStoryCover.State.PINNED, pinnedViewed.state) + assertEquals(1, pinnedViewed.segments) + assertTrue(pinnedViewed.seenSegments.isEmpty()) + + val pinnedPartly = StoriesMapping.item(story(pinned = true, slides = 3), setOf("s2")) + assertEquals(PersonalizationStoryCover.State.PINNED, pinnedPartly.state) + assertEquals(setOf(2), pinnedPartly.seenSegments) + } + + @Test + fun `seen slides persist per shop`() { + val context = ApplicationProvider.getApplicationContext() + val preferences = context.getSharedPreferences("stories_seen_test", Context.MODE_PRIVATE) + StoriesSeenStore(preferences).markSeen(7, "70") + assertEquals(setOf("70"), StoriesSeenStore(preferences).seen(7)) + assertTrue(StoriesSeenStore(preferences).seen(8).isEmpty()) + + val shopA = StoriesSeenStore.forShop(context, "shop-a") + shopA.markSeen(1, "10") + assertTrue(StoriesSeenStore.forShop(context, "shop-b").seen(1).isEmpty()) + assertEquals(setOf("10"), StoriesSeenStore.forShop(context, "shop-a").seen(1)) + } + + // --- Tracking, duration (A6, A7) ------------------------------------------------------------ + + @Test + fun `only positive integer ids are tracked`() { + assertTrue(StoriesMapping.isTrackable(40, "36")) + assertFalse(StoriesMapping.isTrackable(39, "39_0")) + assertFalse(StoriesMapping.isTrackable(39, "0")) + assertFalse(StoriesMapping.isTrackable(39, "-3")) + assertFalse(StoriesMapping.isTrackable(39, "036")) + assertFalse(StoriesMapping.isTrackable(0, "36")) + } + + @Test + fun `a slide without a duration runs 10 seconds`() { + assertEquals(10_000L, StoriesMapping.durationMs(slide())) + assertEquals(10_000L, StoriesMapping.durationMs(slide("duration" to 0))) + assertEquals(6_000L, StoriesMapping.durationMs(slide("duration" to 6))) + } + + // --- Slide look (C1, C3) -------------------------------------------------------------------- + + @Test + fun `only a bare media slide gets the strong scrim`() { + val photo = slide("type" to "image", "background" to "https://x/1.jpg") + assertEquals(StoriesMapping.SCRIM_STRONG, StoriesMapping.scrimAlpha(photo)) + val withText = slide( + "type" to "image", "background" to "https://x/1.jpg", + "elements" to JSONArray().put(JSONObject().put("type", "text_block").put("text_input", "Hi")) + ) + assertEquals(StoriesMapping.SCRIM_LIGHT, StoriesMapping.scrimAlpha(withText)) + val blankText = slide( + "type" to "image", "background" to "https://x/1.jpg", + "elements" to JSONArray().put(JSONObject().put("type", "text_block").put("text_input", " ")) + ) + assertEquals(StoriesMapping.SCRIM_STRONG, StoriesMapping.scrimAlpha(blankText)) + assertEquals(StoriesMapping.SCRIM_LIGHT, StoriesMapping.scrimAlpha(slide())) + } + + @Test + fun `the letterbox takes the slide colour, black without it`() { + assertEquals(Color.parseColor("#112233"), StoriesMapping.letterboxColor(slide("background_color" to "#112233"))) + assertEquals(Color.BLACK, StoriesMapping.letterboxColor(slide("background_color" to ""))) + } + + // --- Links and captions (C9, C11, C12) ------------------------------------------------------ + + @Test + fun `a button opens its own link, without one the product`() { + val product = product("url" to "https://shop/p/1", "deeplink_android" to "app://p/1") + val own = ButtonElement(JSONObject().put("title", "Buy").put("link", "https://web").put("link_android", "app://own")) + assertEquals("app://own", StoriesMapping.buttonLink(own, product)) + val bare = ButtonElement(JSONObject().put("title", "Buy")) + assertEquals("app://p/1", StoriesMapping.buttonLink(bare, product)) + assertEquals("https://shop/p/2", StoriesMapping.buttonLink(bare, product("url" to "https://shop/p/2"))) + assertEquals("", StoriesMapping.buttonLink(bare, null)) + } + + @Test + fun `the promo caption comes from the admin title, else the host text`() { + val titled = ProductElement(JSONObject().put("title", "Ваш код")) + assertEquals("Ваш код", StoriesMapping.promoCaption(titled, "Promo code")) + val blank = ProductElement(JSONObject().put("title", " ")) + assertEquals("Promo code", StoriesMapping.promoCaption(blank, "Promo code")) + } + + @Test + fun `a text block promocode is read, a null one is not`() { + assertEquals("SALE", StoriesMapping.textPromocode(TextBlockElement(JSONObject().put("promocode", " SALE ")))) + assertNull(StoriesMapping.textPromocode(TextBlockElement(JSONObject()))) + assertNull(StoriesMapping.textPromocode(TextBlockElement(JSONObject().put("promocode", JSONObject.NULL)))) + } + + // --- Text block promo on a product slide (H) ----------------------------------------------- + + @Test + fun `a product without a promo shows the text block promo at the regular price`() { + val price = StoriesMapping.price( + product("price" to 1000, "price_formatted" to "1 000 ₽", "discount_percent" to 10), + slidePromo = "SLIDE" + ) + assertEquals(PersonalizationStoryPrice.Type.PROMO_CODE, price.type) + assertEquals("1 000 ₽", price.price) + assertNull(price.oldPrice) + assertEquals("SLIDE", price.promoCode) + } + + @Test + fun `the product promo wins over the text block promo`() { + val price = StoriesMapping.price( + product("price" to 1000, "price_formatted" to "1 000 ₽", "promocode" to "OWN", "price_with_promocode_formatted" to "900 ₽"), + slidePromo = "SLIDE" + ) + assertEquals("OWN", price.promoCode) + assertEquals("900 ₽", price.price) + } + + @Test + fun `a text block promo crosses out only an old price above the regular price`() { + val higher = StoriesMapping.price( + product("price" to 1000, "price_formatted" to "1 000 ₽", "oldprice" to 1500, "oldprice_formatted" to "1 500 ₽"), + slidePromo = "SLIDE" + ) + assertEquals("1 500 ₽", higher.oldPrice) + val lower = StoriesMapping.price( + product("price" to 1000, "price_formatted" to "1 000 ₽", "oldprice" to 900, "oldprice_formatted" to "900 ₽"), + slidePromo = "SLIDE" + ) + assertNull(lower.oldPrice) + } + + @Test + fun `the slide promo is the first text block with a code, blank and null ones are skipped`() { + val blocks = JSONArray() + .put(JSONObject().put("type", "text_block").put("text_input", "Hello")) + .put(JSONObject().put("type", "text_block").put("text_input", "x").put("promocode", JSONObject.NULL)) + .put(JSONObject().put("type", "text_block").put("text_input", "y").put("promocode", " ")) + .put(JSONObject().put("type", "text_block").put("text_input", "Code A1").put("promocode", "A1")) + .put(JSONObject().put("type", "text_block").put("text_input", "Code B2").put("promocode", "B2")) + assertEquals("A1", StoriesMapping.slidePromocode(slide("elements" to blocks))) + assertNull(StoriesMapping.slidePromocode(slide("elements" to JSONArray()))) + } + + // --- Text blocks (C15) ---------------------------------------------------------------------- + + @Test + fun `a text block background takes its opacity, zero means no background`() { + val half = StoriesMapping.textBlockColor(textBlock("#0087E8", "50%"))!! + assertEquals(127, Color.alpha(half)) + assertEquals(0x87, Color.green(half)) + assertNull(StoriesMapping.textBlockColor(textBlock("#0087E8", "0%"))) + assertNull(StoriesMapping.textBlockColor(textBlock("not a colour", "100%"))) + } + + @Test + fun `text alignment maps start, centre and end`() { + fun align(value: String) = StoriesMapping.textAlign(TextBlockElement(JSONObject().put("text_align", value))) + assertEquals(PersonalizationStoryTextBlock.Align.START, align("left")) + assertEquals(PersonalizationStoryTextBlock.Align.START, align("start")) + assertEquals(PersonalizationStoryTextBlock.Align.CENTER, align("center")) + assertEquals(PersonalizationStoryTextBlock.Align.END, align("right")) + assertEquals(PersonalizationStoryTextBlock.Align.END, align("end")) + } + + @Test + fun `a missing line spacing falls back to the preset of that size`() { + assertNull(StoriesMapping.lineHeightSp(TextBlockElement(JSONObject().put("font_size", 20)))) + assertEquals(30f, StoriesMapping.lineHeightSp(TextBlockElement(JSONObject().put("font_size", 20).put("text_line_spacing", 1.5)))!!, 0.01f) + assertEquals(48f, PersonalizationStoryTextBlock.Size.lineHeightFor(48f), 0.01f) + assertEquals(36f, PersonalizationStoryTextBlock.Size.lineHeightFor(30f), 0.01f) + assertEquals(24f, PersonalizationStoryTextBlock.Size.lineHeightFor(20f), 0.01f) + // round(size × ratio): 14 × 1.2 = 16.8 → 17. + assertEquals(17f, PersonalizationStoryTextBlock.Size.lineHeightFor(14f), 0.01f) + // 39 is as far from Large (48) as from Medium (30): the tie goes to Large, ratio 1.0. + assertEquals(39f, PersonalizationStoryTextBlock.Size.lineHeightFor(39f), 0.01f) + assertEquals(PersonalizationStoryTextBlock.Size.LARGE, PersonalizationStoryTextBlock.Size.nearest(39f)) + } + + // --- Loading (C16) -------------------------------------------------------------------------- + + @Test + fun `stories without slides are dropped`() { + val response = JSONObject().put( + "stories", + JSONArray() + .put(storyJson(id = 1, slides = 2)) + .put(storyJson(id = 2, slides = 0)) + ) + assertEquals(listOf(1), StoriesLoader.parse(response).map { it.id }) + assertTrue(StoriesLoader.parse(null).isEmpty()) + } + + private fun product(vararg fields: Pair): Product = + Product(JSONObject().apply { fields.forEach { (key, value) -> put(key, value) } }) + + private fun slide(vararg fields: Pair): Slide = + Slide(JSONObject().put("id", "1").apply { fields.forEach { (key, value) -> put(key, value) } }) + + private fun story( + pinned: Boolean = false, + viewed: Boolean = false, + startPosition: Int = 0, + slides: Int = 3 + ): Story = Story(storyJson(1, slides, pinned, viewed, startPosition)) + + private fun storyJson( + id: Int, + slides: Int, + pinned: Boolean = false, + viewed: Boolean = false, + startPosition: Int = 0 + ): JSONObject = JSONObject() + .put("id", id) + .put("name", "Story") + .put("pinned", pinned) + .put("viewed", viewed) + .put("start_position", startPosition) + .put("slides", JSONArray().apply { + repeat(slides) { put(JSONObject().put("id", "s$it").put("elements", JSONArray())) } + }) + + private fun textBlock(color: String, opacity: String) = TextBlockElement( + JSONObject() + .put("text_input", "Text") + .put("text_background_color", color) + .put("text_background_color_opacity", opacity) + ) +} diff --git a/personalization-sdk/src/test/kotlin/com/personalization/ui/widgets/StoriesViewerStateTest.kt b/personalization-sdk/src/test/kotlin/com/personalization/ui/widgets/StoriesViewerStateTest.kt new file mode 100644 index 00000000..bbe7c521 --- /dev/null +++ b/personalization-sdk/src/test/kotlin/com/personalization/ui/widgets/StoriesViewerStateTest.kt @@ -0,0 +1,294 @@ +package com.personalization.ui.widgets + +import com.personalization.ui.widgets.StoriesViewerState.Move +import com.personalization.ui.widgets.StoriesViewerState.Pause +import com.personalization.ui.widgets.StoriesViewerState.SlideShape +import com.personalization.ui.widgets.StoriesViewerState.StoryShape +import com.personalization.ui.widgets.StoriesViewerState.Zone +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test + +/** The viewer's navigation, pause and seen logic, without any view. */ +class StoriesViewerStateTest { + + private val seen = MemorySeen() + + @Test + fun `a fresh story opens at the server start position and is not seen until it settles`() { + val state = state(story(1, slides = 3, startPosition = 1)) + assertEquals(1, state.slideIndex) + assertTrue(seen.seen(1).isEmpty()) + + assertTrue(state.enter()) + assertEquals(setOf("1_1"), seen.seen(1)) + // Entering twice (adapter bind + page settle) starts the slide once. + assertFalse(state.enter()) + } + + @Test + fun `a partly seen story opens at its first unseen slide, a viewed one at the start`() { + seen.markSeen(1, "1_0") + seen.markSeen(1, "1_2") + assertEquals(1, state(story(1, slides = 4, startPosition = 3)).slideIndex) + + listOf("1_1", "1_3").forEach { seen.markSeen(1, it) } + assertEquals(0, state(story(1, slides = 4, startPosition = 3)).slideIndex) + assertEquals(0, state(story(2, slides = 4, startPosition = 3, viewed = true)).slideIndex) + } + + @Test + fun `the start position is clamped to the slides`() { + assertEquals(2, state(story(1, slides = 3, startPosition = 9)).slideIndex) + } + + @Test + fun `tap zones are thirds, the centre does nothing and RTL mirrors the edges`() { + assertEquals(Zone.PREVIOUS, StoriesViewerState.zone(10f, 300, rtl = false)) + assertEquals(Zone.CENTER, StoriesViewerState.zone(150f, 300, rtl = false)) + assertEquals(Zone.NEXT, StoriesViewerState.zone(290f, 300, rtl = false)) + assertEquals(Zone.NEXT, StoriesViewerState.zone(10f, 300, rtl = true)) + assertEquals(Zone.PREVIOUS, StoriesViewerState.zone(290f, 300, rtl = true)) + + val state = entered(story(1, slides = 3)) + assertEquals(Move.None, state.tap(Zone.CENTER)) + assertEquals(0, state.slideIndex) + } + + @Test + fun `next walks the slides, then the stories, then closes`() { + val state = entered(story(1, slides = 2), story(2, slides = 1)) + assertEquals(Move.Slide, state.tap(Zone.NEXT)) + assertEquals(1, state.slideIndex) + assertEquals(Move.Story(1), state.tap(Zone.NEXT)) + // Leaving the story stops its clock until the pager settles on the next one. + assertFalse(state.isRunning) + + state.selectStory(1) + state.enter() + assertEquals(Move.Close, state.next()) + } + + @Test + fun `previous on the first slide of the first story restarts it`() { + val state = entered(story(1, slides = 2)) + state.mediaReady() + state.tick(1500) + assertEquals(Move.Restart, state.previous()) + assertEquals(0, state.slideIndex) + assertEquals(0L, state.elapsedMs) + assertTrue(state.isRunning) + } + + @Test + fun `previous on the first slide of a later story goes back a story`() { + val state = entered(story(1, slides = 2), story(2, slides = 2), start = 1) + assertEquals(Move.Story(0), state.previous()) + } + + @Test + fun `swiping back into a story applies the start rule`() { + val state = entered(story(1, slides = 3), story(2, slides = 2)) + state.next() + state.selectStory(1) + state.enter() + state.selectStory(0) + // Slides 0 and 1 of the first story were seen: it reopens at slide 2. + assertEquals(2, state.slideIndex) + assertFalse(state.entered) + } + + @Test + fun `the clock runs only when the media is ready and nothing pauses it`() { + val state = entered(story(1, slides = 2, durationMs = 5000)) + assertTrue(state.isPaused(Pause.LOADING)) + assertEquals(Move.None, state.tick(6000)) + assertEquals(0L, state.elapsedMs) + + state.mediaReady() + state.tick(2000) + assertEquals(0.4f, state.progress, 0.001f) + + for (reason in listOf(Pause.HOLD, Pause.DRAG, Pause.SHEET, Pause.BACKGROUND, Pause.HOST)) { + assertTrue(state.setPaused(reason, true)) + assertEquals(Move.None, state.tick(10_000)) + assertTrue(state.setPaused(reason, false)) + } + assertEquals(2000L, state.elapsedMs) + + assertEquals(Move.Slide, state.tick(3000)) + assertEquals(1, state.slideIndex) + } + + @Test + fun `a background pause survives a slide change`() { + val state = entered(story(1, slides = 3)) + state.mediaReady() + state.setPaused(Pause.BACKGROUND, true) + state.next() + state.mediaReady() + assertFalse(state.isRunning) + state.setPaused(Pause.BACKGROUND, false) + assertTrue(state.isRunning) + } + + @Test + fun `the player keeps playing while loading but stops for a hold`() { + val state = entered(story(1, slides = 1)) + assertTrue(state.playerShouldPlay) + state.buffering(true) + assertTrue(state.playerShouldPlay) + assertFalse(state.isRunning) + state.setPaused(Pause.HOLD, true) + assertFalse(state.playerShouldPlay) + } + + @Test + fun `a video slide follows the player and ends with the video`() { + val state = entered(story(1, slides = 2, durationMs = 10_000)) + state.mediaReady(videoDurationMs = 30_000) + assertEquals(StoriesViewerState.Clock.PLAYER, state.clock) + // Timer ticks do not move a video slide: only the playback position does. + assertEquals(Move.None, state.tick(20_000)) + state.videoPosition(15_000) + assertEquals(0.5f, state.progress, 0.001f) + assertEquals(Move.Slide, state.mediaEnded()) + } + + @Test + fun `a video of unknown length falls back to the admin duration`() { + val state = entered(story(1, slides = 2, durationMs = 4000)) + state.mediaReady(videoDurationMs = null) + assertEquals(StoriesViewerState.Clock.TIMER, state.clock) + assertEquals(Move.Slide, state.tick(4000)) + } + + @Test + fun `a gif slide lasts the longer of its loop and the admin duration`() { + val longer = entered(story(1, slides = 2, durationMs = 5000)) + longer.mediaReady(animationLoopMs = 8000) + assertEquals(StoriesViewerState.Clock.TIMER, longer.clock) + assertEquals(Move.None, longer.tick(5000)) + assertEquals(Move.Slide, longer.tick(3000)) + + val shorter = entered(story(2, slides = 2, durationMs = 5000)) + shorter.mediaReady(animationLoopMs = 700) + assertEquals(Move.Slide, shorter.tick(5000)) + } + + @Test + fun `a gif slide keeps its length on restart and measures it again after a retry`() { + val state = entered(story(1, slides = 2, durationMs = 5000)) + state.mediaReady(animationLoopMs = 8000) + state.tick(6000) + assertEquals(Move.Restart, state.previous()) + assertEquals(8000L, state.durationMs) + + state.mediaFailed() + state.retry() + assertEquals(5000L, state.durationMs) + state.mediaReady(animationLoopMs = 8000) + assertEquals(8000L, state.durationMs) + } + + @Test + fun `a failed media pauses the slide until retried`() { + val state = entered(story(1, slides = 2)) + state.mediaFailed() + assertTrue(state.hasError) + assertFalse(state.isRunning) + assertEquals(Move.None, state.tick(60_000)) + + state.retry() + assertFalse(state.hasError) + assertTrue(state.isPaused(Pause.LOADING)) + state.mediaReady() + assertTrue(state.isRunning) + } + + @Test + fun `an open sheet blocks taps, closes on a tap or back, and resets on a slide change`() { + val state = entered(story(1, slides = 3)) + state.mediaReady() + state.setSheet(true) + assertFalse(state.isRunning) + + assertEquals(Move.CloseSheet, state.tap(Zone.NEXT)) + assertEquals(0, state.slideIndex) + assertFalse(state.sheetOpen) + assertTrue(state.isRunning) + + state.setSheet(true) + assertEquals(Move.CloseSheet, state.back()) + assertEquals(Move.Close, state.back()) + + state.setSheet(true) + state.next() + assertFalse(state.sheetOpen) + assertFalse(state.isPaused(Pause.SHEET)) + } + + @Test + fun `opening another story from the host pages there inside the open viewer`() { + seen.markSeen(3, "3_0") + val state = entered(story(1, slides = 2), story(2, slides = 2), story(3, slides = 3)) + state.mediaReady() + state.setSheet(true) + + assertEquals(Move.Story(2), state.jumpTo(2)) + assertFalse(state.sheetOpen) + // The clock stands until the pager settles on the new story. + assertFalse(state.isRunning) + assertEquals(Move.None, state.tick(StoriesMapping.DEFAULT_DURATION_MS)) + + state.selectStory(2) + assertTrue(state.enter()) + assertEquals(1, state.slideIndex) + } + + @Test + fun `opening the current or a missing story from the host changes nothing`() { + val state = entered(story(1, slides = 2), story(2, slides = 2)) + assertEquals(Move.None, state.jumpTo(0)) + assertEquals(Move.None, state.jumpTo(5)) + assertTrue(state.entered) + } + + @Test + fun `the time is up only once per slide`() { + val state = entered(story(1, slides = 1), story(2, slides = 1)) + state.mediaReady() + assertEquals(Move.Story(1), state.tick(StoriesMapping.DEFAULT_DURATION_MS)) + assertEquals(Move.None, state.tick(16)) + } + + @Test + fun `a story without slides does not crash the state`() { + val state = StoriesViewerState(listOf(StoryShape(1, emptyList())), seen) + assertFalse(state.enter()) + assertEquals(Move.Close, state.next()) + assertEquals(Move.None, state.tick(1000)) + } + + private fun state(vararg stories: StoryShape, start: Int = 0) = StoriesViewerState(stories.toList(), seen, start) + + private fun entered(vararg stories: StoryShape, start: Int = 0) = + state(*stories, start = start).also { it.enter() } + + private fun story( + id: Int, + slides: Int, + startPosition: Int = 0, + viewed: Boolean = false, + durationMs: Long = StoriesMapping.DEFAULT_DURATION_MS + ) = StoryShape(id, List(slides) { SlideShape("${id}_$it", durationMs) }, viewed, startPosition) + + private class MemorySeen : SeenSlides { + private val map = HashMap>() + override fun seen(storyId: Int): Set = map[storyId].orEmpty() + override fun markSeen(storyId: Int, slideId: String) { + map.getOrPut(storyId) { HashSet() }.add(slideId) + } + } +} diff --git a/personalization-sdk/src/test/kotlin/com/personalization/ui/widgets/StoriesViewerSupportTest.kt b/personalization-sdk/src/test/kotlin/com/personalization/ui/widgets/StoriesViewerSupportTest.kt new file mode 100644 index 00000000..ead7d40c --- /dev/null +++ b/personalization-sdk/src/test/kotlin/com/personalization/ui/widgets/StoriesViewerSupportTest.kt @@ -0,0 +1,117 @@ +package com.personalization.ui.widgets + +import android.os.Handler +import android.os.Looper +import java.util.concurrent.TimeUnit +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.Shadows.shadowOf +import org.robolectric.annotation.Config + +/** The viewer's helpers: timers that stand still in the background, the kept sound choice. */ +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28]) +class StoriesViewerSupportTest { + + private val looper = shadowOf(Looper.getMainLooper()) + private val handler = Handler(Looper.getMainLooper()) + + @Test + fun `a frozen timer stands still and then runs out its remaining time`() { + var fired = 0 + val timer = StoryTimer(handler) { fired++ } + timer.start(10_000) + idle(4_000) + + timer.freeze(true) + idle(60_000) + assertEquals(0, fired) + assertTrue(timer.isScheduled) + + timer.freeze(false) + idle(5_999) + assertEquals(0, fired) + idle(1) + assertEquals(1, fired) + assertFalse(timer.isScheduled) + } + + @Test + fun `a timer started while frozen counts only after the thaw`() { + var fired = 0 + val timer = StoryTimer(handler) { fired++ } + timer.freeze(true) + timer.start(15_000) + idle(30_000) + assertEquals(0, fired) + + timer.freeze(false) + idle(15_000) + assertEquals(1, fired) + } + + @Test + fun `a cancelled or restarted timer does not fire for the old start`() { + var fired = 0 + val timer = StoryTimer(handler) { fired++ } + timer.start(10_000) + timer.freeze(true) + timer.cancel() + timer.freeze(false) + idle(20_000) + assertEquals(0, fired) + + timer.start(10_000) + idle(6_000) + timer.start(10_000) + idle(6_000) + assertEquals(0, fired) + idle(4_000) + assertEquals(1, fired) + } + + @Test + fun `an audio interruption silences this viewer but keeps the chosen sound`() { + val sound = StoriesSound() + sound.choose(false) + + assertTrue(sound.silence()) + assertTrue(sound.muted) + assertFalse(StoriesSound.chosenMuted) + // The next viewer opens with the kept choice. + assertFalse(StoriesSound().muted) + } + + @Test + fun `the user's own choice lifts the silence`() { + val sound = StoriesSound() + sound.choose(false) + sound.silence() + + sound.choose(false) + assertFalse(sound.muted) + assertFalse(sound.silenced) + } + + @Test + fun `nothing is silenced while the sound is already off`() { + val sound = StoriesSound() + sound.choose(true) + + assertFalse(sound.silence()) + assertFalse(sound.silenced) + assertTrue(StoriesSound.chosenMuted) + } + + @After + fun resetSound() { + StoriesSound.chosenMuted = true + } + + private fun idle(ms: Long) = looper.idleFor(ms, TimeUnit.MILLISECONDS) +} diff --git a/personalization-sdk/src/test/kotlin/com/personalization/ui/widgets/StorySlideViewTest.kt b/personalization-sdk/src/test/kotlin/com/personalization/ui/widgets/StorySlideViewTest.kt new file mode 100644 index 00000000..75308f92 --- /dev/null +++ b/personalization-sdk/src/test/kotlin/com/personalization/ui/widgets/StorySlideViewTest.kt @@ -0,0 +1,212 @@ +package com.personalization.ui.widgets + +import android.app.Activity +import android.os.Looper +import android.os.SystemClock +import android.view.MotionEvent +import android.view.View +import android.view.ViewGroup +import android.widget.ImageView +import androidx.core.graphics.Insets +import com.bumptech.glide.load.resource.gif.GifDrawable +import com.personalization.Product +import com.personalization.stories.models.Slide +import com.personalization.stories.models.elements.ButtonElement +import com.personalization.ui.components.PersonalizationStoryCard +import com.personalization.ui.components.PersonalizationStoryPrice +import com.personalization.ui.components.PersonalizationStoryTextBlock +import org.json.JSONArray +import org.json.JSONObject +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.Robolectric +import org.robolectric.RobolectricTestRunner +import org.robolectric.Shadows.shadowOf +import org.robolectric.annotation.Config + +/** One slide's touch routing: the controls over an open products sheet, the product picture. */ +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28]) +class StorySlideViewTest { + + private val activity = Robolectric.buildActivity(Activity::class.java).setup().get() + private val host = FakeHost() + + @Test + fun `the close cross still gets the touch while the sheet is open`() { + host.sheetOpen = true + val view = laidOut(slideWithProducts()) + + assertFalse(view.onInterceptTouchEvent(down(pointIn(view.navigation.closeButton)))) + } + + @Test + fun `a touch elsewhere outside the open sheet only closes the sheet`() { + host.sheetOpen = true + val view = laidOut(slideWithProducts()) + + val middle = pointIn(view, 0.5f, 0.4f) + assertTrue(view.onInterceptTouchEvent(down(middle))) + host.sheetOpen = false + assertFalse(view.onInterceptTouchEvent(down(middle))) + } + + @Test + fun `a tap on the product picture pages the story and does not open the product`() { + val view = laidOut(productSlide()) + val card = view.first(PersonalizationStoryCard::class.java)!! + val picture = card.imageView.parent as View + assertFalse(picture.isClickable) + + // The right edge of the picture lies in the right third of the slide: a tap there pages forward. + val slideAt = IntArray(2).also(view::getLocationOnScreen) + val pictureAt = IntArray(2).also(picture::getLocationOnScreen) + val x = (pictureAt[0] - slideAt[0] + picture.width - 2).toFloat() + val y = (pictureAt[1] - slideAt[1] + picture.height / 2).toFloat() + assertTrue("the picture must reach the right third", x > view.width * 2 / 3f) + val now = SystemClock.uptimeMillis() + view.dispatchTouchEvent(MotionEvent.obtain(now, now, MotionEvent.ACTION_DOWN, x, y, 0)) + view.dispatchTouchEvent(MotionEvent.obtain(now, now + 50, MotionEvent.ACTION_UP, x, y, 0)) + + assertEquals(1, host.taps.size) + assertEquals(StoriesViewerState.Zone.NEXT, StoriesViewerState.zone(host.taps[0], view.width, false)) + assertTrue(host.products.isEmpty()) + } + + @Test + fun `a product slide shows its text block promo in the card and draws no text block`() { + val slide = Slide( + JSONObject() + .put("id", "4") + .put( + "elements", + JSONArray() + .put(JSONObject().put("type", "product").put("item", JSONObject().put("id", "p1").put("name", "Sneakers").put("price_formatted", "100 ₽"))) + .put(JSONObject().put("type", "text_block").put("text_input", "Your code SALE10").put("promocode", "SALE10")) + ) + ) + val view = laidOut(slide) + + val card = view.first(PersonalizationStoryCard::class.java)!! + assertEquals("SALE10", card.price.promoCode) + assertEquals(PersonalizationStoryPrice.Type.PROMO_CODE, card.price.type) + assertNull(view.first(PersonalizationStoryTextBlock::class.java)) + } + + @Test + fun `only the slide background may play a gif, the video poster stays on the first frame`() { + StorySlideView(activity, 0, 0, mediaSlide("image", "https://example.com/a.gif"), 1, host) + StorySlideView(activity, 0, 0, mediaSlide("video", "https://example.com/v.mp4", "https://example.com/p.gif"), 1, host) + + assertEquals(listOf("https://example.com/a.gif"), host.slideImages) + assertEquals(listOf("https://example.com/p.gif"), host.images) + } + + private fun mediaSlide(type: String, background: String, preview: String = ""): Slide = Slide( + JSONObject() + .put("id", "3") + .put("type", type) + .put("background", background) + .put("preview", preview) + .put("elements", JSONArray()) + ) + + /** On screen: an unattached view has no location, and the slide hit-tests by location. */ + private fun laidOut(slide: Slide): StorySlideView = + StorySlideView(activity, 0, 0, slide, 1, host).also { view -> + activity.setContentView(view, ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)) + shadowOf(Looper.getMainLooper()).idle() + assertTrue(view.isAttachedToWindow && view.width > 0) + } + + /** A screen point at the fractions of [view]'s size — raw coordinates, as the slide reads them. */ + private fun pointIn(view: View, fx: Float = 0.5f, fy: Float = 0.5f): Pair { + val location = IntArray(2) + view.getLocationOnScreen(location) + return location[0] + view.width * fx to location[1] + view.height * fy + } + + private fun down(point: Pair): MotionEvent { + val now = SystemClock.uptimeMillis() + return MotionEvent.obtain(now, now, MotionEvent.ACTION_DOWN, point.first, point.second, 0) + } + + private fun slideWithProducts(): Slide = Slide( + JSONObject() + .put("id", "1") + .put( + "elements", + JSONArray().put( + JSONObject() + .put("type", "products") + .put("products", JSONArray().put(JSONObject().put("id", "p1").put("name", "Sneakers"))) + ) + ) + ) + + private fun productSlide(): Slide = Slide( + JSONObject() + .put("id", "2") + .put( + "elements", + JSONArray().put( + JSONObject() + .put("type", "product") + .put("item", JSONObject().put("id", "p1").put("name", "Sneakers").put("price_formatted", "100 ₽")) + ) + ) + ) + + private fun View.first(type: Class): T? { + if (type.isInstance(this)) return type.cast(this) + if (this !is ViewGroup) return null + for (index in 0 until childCount) getChildAt(index).first(type)?.let { return it } + return null + } + + private class FakeHost : StorySlideHost { + override val texts = StoriesTexts("Promo code", "Copied", "More info", "Used products", "Hide products", "Retry", "Close", "Sound on", "Sound off") + override val muted = true + override var sheetOpen = false + override val insets: Insets = Insets.NONE + val products = mutableListOf() + + val images = mutableListOf() + val slideImages = mutableListOf() + + override fun loadImage(view: ImageView, url: String, onReady: (() -> Unit)?, onFailed: (() -> Unit)?) { + images += url + } + + override fun loadSlideImage( + view: ImageView, + url: String, + onAnimation: (Long?, GifDrawable) -> Unit, + onReady: () -> Unit, + onFailed: () -> Unit + ) { + slideImages += url + } + val taps = mutableListOf() + + override fun onTap(x: Float, width: Int, rtl: Boolean) { + taps += x + } + override fun onHold(hold: Boolean) = Unit + override fun onOutsideSheetTap() = Unit + override fun onSheet(open: Boolean) = Unit + override fun onButton(button: ButtonElement, product: Product?) = Unit + override fun onProduct(product: Product) { + products += product + } + override fun onCarouselProduct(product: Product) = Unit + override fun onPromoCopied() = Unit + override fun onSoundToggle() = Unit + override fun onRetry(view: StorySlideView) = Unit + override fun onClose() = Unit + } +}