Balloon

:balloon: Modernized and sophisticated tooltips, fully customizable with an arrow and animations on Android.

## Who's using Balloon?
**👉 [Check out who's using Balloon](/usecases.md)**

Balloon hits **+500,000 downloads every month** around the globe! :balloon:

![globe](https://user-images.githubusercontent.com/24237865/196018576-a9c87534-81a2-4618-8519-0024b67964bf.png)

## Balloon in Jetpack Compose

If you want to use Balloon in your Jetpack Compose project, check out the **[Balloon in Jetpack Compose](https://github.com/skydoves/Balloon#balloon-in-jetpack-compose-1)** guidelines. You can also check out the blog post **[Tooltips for Jetpack Compose: Improve User Experience to the Next Level](https://medium.com/@skydoves/tooltips-for-jetpack-compose-improve-user-experience-to-the-next-level-68791ab8e07f)** for more details.

## Including in your project
[![Maven Central](https://img.shields.io/maven-central/v/com.github.skydoves/balloon.svg?label=Maven%20Central)](https://search.maven.org/search?q=g:%22com.github.skydoves%22%20AND%20a:%22balloon%22)

### Gradle
Add the dependency below to your **module**'s `build.gradle` file:

```kotlin
dependencies {
    implementation("com.github.skydoves:balloon:1.6.5")
}
```

## SNAPSHOT
[![Balloon](https://img.shields.io/static/v1?label=snapshot&message=balloon&logo=apache%20maven&color=C71A36)](https://oss.sonatype.org/content/repositories/snapshots/com/github/skydoves/balloon/)

 See how to import the snapshot

### Including the SNAPSHOT
Snapshots of the current development version of Balloon are available, which track [the latest versions](https://oss.sonatype.org/content/repositories/snapshots/com/github/skydoves/balloon/).

To import snapshot versions on your project, add the code snippet below on your gradle file.
```kotlin
repositories {
   maven(url = "https://oss.sonatype.org/content/repositories/snapshots/")
}
```

Next, add the below dependency to your **module**'s `build.gradle` file.
```kotlin
dependencies {
    implementation("com.github.skydoves:balloon:1.6.5-SNAPSHOT")
}
```

## How to Use
Balloon supports both Kotlin and Java projects, so you can reference it by your language.

### Create Balloon with Kotlin
We can create an instance of the Balloon with the `Balloon.Builder` class.

```kotlin
val balloon = Balloon.Builder(context)
  .setWidthRatio(1.0f)
  .setHeight(BalloonSizeSpec.WRAP)
  .setText("Edit your profile here!")
  .setTextColorResource(R.color.white_87)
  .setTextSize(15f)
  .setIconDrawableResource(R.drawable.ic_edit)
  .setArrowPositionRules(ArrowPositionRules.ALIGN_ANCHOR)
  .setArrowSize(10)
  .setArrowPosition(0.5f)
  .setPadding(12)
  .setCornerRadius(8f)
  .setBackgroundColorResource(R.color.skyBlue)
  .setBalloonAnimation(BalloonAnimation.ELASTIC)
  .setLifecycleOwner(lifecycle)
  .build()
```

### Create Balloon with Kotlin DSL
We can also create an instance of the Balloon with the Kotlin DSL.

 Keep reading for more details

You can create an instance of the Balloon with `createBalloon` as the example below:
```kotlin
val balloon = createBalloon(context) {
  setWidthRatio(1.0f)
  setHeight(BalloonSizeSpec.WRAP)
  setText("Edit your profile here!")
  setTextColorResource(R.color.white_87)
  setTextSize(15f)
  setIconDrawableResource(R.drawable.ic_edit)
  setArrowPositionRules(ArrowPositionRules.ALIGN_ANCHOR)
  setArrowSize(10)
  setArrowPosition(0.5f)
  setPadding(12)
  setCornerRadius(8f)
  setBackgroundColorResource(R.color.skyBlue)
  setBalloonAnimation(BalloonAnimation.ELASTIC)
  setLifecycleOwner(lifecycle)
  build()
}
```

### Create Balloon with Java
You can create an instance of the Balloon with Java by using the `Balloon.Builder` class.

 Keep reading for more details

You can create an instance of the Balloon as the following example below:
```java
Balloon balloon = new Balloon.Builder(context)
    .setArrowSize(10)
    .setArrowOrientation(ArrowOrientation.TOP)
    .setArrowPositionRules(ArrowPositionRules.ALIGN_ANCHOR)
    .setArrowPosition(0.5f)
    .setWidth(BalloonSizeSpec.WRAP)
    .setHeight(65)
    .setTextSize(15f)
    .setCornerRadius(4f)
    .setAlpha(0.9f)
    .setText("You can access your profile from now on.")
    .setTextColor(ContextCompat.getColor(context, R.color.white_93))
    .setTextIsHtml(true)
    .setIconDrawable(ContextCompat.getDrawable(context, R.drawable.ic_profile))
    .setBackgroundColor(ContextCompat.getColor(context, R.color.colorPrimary))
    .setOnBalloonClickListener(onBalloonClickListener)
    .setBalloonAnimation(BalloonAnimation.FADE)
    .setLifecycleOwner(lifecycleOwner)
    .build();
```

### Show up Balloon
We can show up the Balloon using the functions below. If we use `showAlign__` method, we can show up the Balloon based on alignments (**top, bottom, right, left**). Also, we can adjust specific positions of the Balloon by using `x-Offset` and `y-Offset` parameters.

```kotlin
balloon.showAlignTop(anchor: View) // shows the balloon on an anchor view as the top alignment.
balloon.showAlignTop(anchor: View, xOff: Int, yOff: Int) // shows top alignment with x-off and y-off.
balloon.showAlignBottom(anchor: View) // shows the balloon on an anchor view as the bottom alignment.
balloon.showAlignBottom(anchor: View, xOff: Int, yOff: Int) // shows bottom alignment with x-off and y-off.
balloon.showAlignEnd(anchor: View) // shows the balloon on an anchor view as the end alignment.
balloon.showAlignEnd(anchor: View, xOff: Int, yOff: Int) // shows end alignment with x-off and y-off.
balloon.showAlignStart(anchor: View) // shows the balloon on an anchor view as the start alignment.
balloon.showAlignStart(anchor: View, xOff: Int, yOff: Int) // shows start alignment with x-off and y-off.
balloon.showAsDropDown(anchor: View) // shows the balloon as a dropdown without any alignments.
balloon.showAsDropDown(anchor: View, xOff: Int, yOff: Int) // shows no alignments with x-off and y-off.
balloon.showAtCenter(anchor: View, xOff: Int, yOff: Int, centerAlign: BalloonCenterAlign.TOP)
// shows the balloon over the anchor view (overlap) as the center aligns.
```

Also, We can show up the Balloon with Kotlin extensions.

```kotlin
myButton.showAlignTop(balloon)
```

### Dismiss Balloon
We can dismiss the Balloon by using the `Balloon.dismiss()` method.

```kotlin
balloon.dismiss()
balloon.dismissWithDelay(1000L) // dismisses 1000 milliseconds later when the popup is shown
```

We can dismiss automatically with delay after the Balloon is showing up with the `setAutoDismissDuration` method..

```kotlin
Balloon.Builder(context)
   // dismisses automatically 1000 milliseconds later when the popup is shown.
   .setAutoDismissDuration(1000L)
   ...
```

### Show up Balloon Sequentially
We can show up a couple of Balloons sequentially with the `relayShow__` and `await__` methods.

```kotlin
customListBalloon
  .relayShowAlignBottom(customProfileBalloon, circleImageView) // relay to customListBalloon
  .relayShowAlignTop(customTagBalloon, bottomNavigationView, 130, 0) // relay to customProfileBalloon

// show sequentially customListBalloon-customProfileBalloon-customTagBalloon
customListBalloon.showAlignBottom(anchorView)
```
```kotlin
coroutineScope.launch {
  customListBalloon.awaitAlignBottom(anchorView)
  customProfileBalloon.awaitAlignBottom(circleImageView, 0, 0)
  customTagBalloon.awaitAlignTop(bottomNavigationView, 130, 0)
}
```

> Note: The `relayShow__` and `await__` methods overwrite the `setOnDismissListener` internally, so you can't use the `setOnDismissListener` at the same time.

#### Parallel Displaying
We can show multiple balloons at the same with sequential behaviour.
```kotlin
lifecycleScope.launch {
  // shows balloons at the same time
  awaitBalloons {
    // dismissing of any balloon dismisses all of them. Default behaviour
    dismissSequentially = false

    textView.alignTop(balloonAlignTop)
    textView.alignStart(balloonAlignStart)
    textView.alignEnd(balloonAlignEnd)
    textView.alignBottom(balloonAlignBottom)
  }

  // shows another group after dismissing the previous group.
  awaitBalloons {
    dismissSequentially = true // balloons dismissed individually

    imageView.alignTop(balloonAlignTop)
    imageView.alignStart(balloonAlignStart)
    imageView.alignEnd(balloonAlignEnd)
    imageView.alignBottom(balloonAlignBottom)
  }
}
```
> Note: The methods inside `awaitBalloons` are `atCenter`, `asDropdown`, `alignTop` and etc. Don't confuse with `show__` and `await__` methods.

### Width and height
We can adjust specific width and height sizes of Balloon with the below builder methods. If we don't set any specific sizes of the width and height of the Balloon, the size of the Balloon will be decided by the content.

#### Specific size
We can set specific sizes of the Balloon regardless size of the contents.

```kotlin
balloon.setWidth(220) // sets 220dp width size.
balloon.setHeight(160) // sets 160dp height size.
```

#### Wrap Content Sizes
We can set dynamic sizes of Balloon, which depends on sizes of the internal content.

```kotlin
balloon.setWidth(BalloonSizeSpec.WRAP) // sets width size depending on the content's size.
balloon.setHeight(BalloonSizeSpec.WRAP) // sets height size depending on the content's size.
```

#### Depending on Screen Size
Also, we can set the width size depending on the ratio of the screen's size (horizontal).

```kotlin
balloon.setWidthRatio(0.5f) // sets width as 50% of the horizontal screen's size.
```

### Padding
Balloon wraps contents. We can adjust the content size of the Balloon by adding paddings on the content like.

```kotlin
balloon.setPadding(6) // sets 6dp padding to all directions (left-top-right-bottom)
balloon.setPaddingLeft(8) // sets 8dp padding to content's left.
balloon.setPaddingTop(12) // sets 12dp padding to content's top.
```

### Margin
If the location of the balloon according to the anchor would be located at the boundaries on the screen,

the balloon will be stick to the end of the screen. In this case, we can give horizontal margins to the balloon.
```kotlin
.setMargin(12) // sets the margin on the balloon all directions.
.setMarginLeft(14) // sets the left margin on the balloon.
.setMarginRight(14) // sets the right margin on the balloon.
```

### Arrow Composition
We can customize the arrow on the Balloon with various methods. For more details, check out the [Balloon.Builder](https://skydoves.github.io/libraries/balloon/html/balloon/com.skydoves.balloon/-balloon/-builder/index.html).

```kotlin
.setIsVisibleArrow(true) // sets the visibility of the arrow.
.setArrowSize(10) // sets the arrow size.
.setArrowSize(BalloonSizeSpec.WRAP) // sets arrow size depending on the original resources' size.
.setArrowPosition(0.8f) // sets the arrow position using the popup size's ratio (0 ~ 1.0)
.setArrowOrientation(ArrowOrientation.TOP) // sets the arrow orientation. top, bottom, left, right
.setArrowDrawable(ContextCompat.getDrawable(context, R.drawable.arrow)) // sets the arrow drawable.
```

#### ArrowPositionRules
We can decide the position of the arrow depending on the aligning rules with the `ArrowPositionRules`.

```kotlin
// Align the arrow position depending on an anchor.
// if `arrowPosition` is 0.5, the arrow will be located in the middle of an anchor.
.setArrowPositionRules(ArrowPositionRules.ALIGN_ANCHOR) // default

// Align the arrow position depending on the balloon popup body.
// if `arrowPosition` is 0.5, he arrow will be located in the middle of the tooltip.
.setArrowPositionRules(ArrowPositionRules.ALIGN_BALLOON)
```

#### ArrowOrientationRules
We can decide the orientation of the arrow depending on the aligning rules with the `ArrowOrientationRules`.

```kotlin
// Align depending on the position of an anchor.
// For example, `arrowOrientation` is ArrowOrientation.TOP and
// we want to show up the balloon under an anchor using the `Balloon.showAlignBottom`.
// However, if there is not enough free space to place the tooltip at the bottom of the anchor,
// tooltips will be placed top of the anchor and the orientation of the arrow will be `ArrowOrientation.BOTTOM`.
.setArrowOrientationRules(ArrowOrientationRules.ALIGN_ANCHOR) // default

// Align to fixed ArrowOrientation value.
.setArrowOrientationRules(ArrowOrientationRules.ALIGN_FIXED)
```

Below previews are shows examples of `setArrowOrientation` and `setArrowPosition` methods.

The `setArrowPosition` measures the Balloon's size and sets the arrow's position with the ratio value.

Orientation: BOTTOM
 Position: 0.62
 showAlignTop | Orientation: TOP
 Position : 0.5
 showAlignBottom | Orientation: START
 Position: 0.5
 showAlignStart | Orientation: END
 Position: 0.5
 showAlignEnd |
| :---------------: | :---------------: | :---------------: | :---------------: |
|  |  |  |  |

### Text Composition
We can customize the text on the Balloon.

```kotlin
.setText("You can edit your profile now!")
.setTextSize(15f)
.setTextTypeface(Typeface.BOLD)
.setTextColorResource(R.color.colorAccent))
.setTextGravity(Gravity.START)
```

If your text includes HTML tags, you can render the text by enabling HTML option with `setTextIsHtml` method.
```java
.setTextIsHtml(true)
```
This method will parse the text with the `Html.fromHtml(text)` internally.

### TextForm
`TextForm` has some attributes for `TextView` to customize the text of the Balloon. You can create the `TextForm` instance and reuse it on multiple Balloons.

```kotlin
val textForm = TextForm.Builder(context)
  .setText("Edit you profile here!")
  .setTextColorResource(R.color.white_87)
  .setTextSize(14f)
  .setTextTypeface(Typeface.BOLD)
  .build()

val balloon = Balloon.Builder(context)
  .setTextForm(textForm)
  ...
```

 Create TextForm with Kotlin DSL

You can create an instance of the `TextForm` with Kotlin DSL as the example below:

```kotlin
val textForm = textForm(context) {
  setText("Edit you profile here!")
  setTextColorResource(R.color.white_87)
  setTextSize(14f)
  setTextTypeface(Typeface.BOLD)
}

val balloon = Balloon.Builder(context)
  .setTextForm(textForm)
  ...
```

 Create TextForm with Java

You can create an instance of the `TextForm` with Java as the example below:

```java
TextForm textForm = new TextForm.Builder(context)
  .setText("Edit you profile here!")
  .setTextColorResource(R.color.white_87)
  .setTextSize(14f)
  .setTextTypeface(Typeface.BOLD)
  .build();

Balloon balloon = new Balloon.Builder(context)
  .setTextForm(textForm)
  ...
```

### Icon Composition
We can customize the icon on the balloon.

```java
.setIconSpace(10) // sets right margin of the icon.
.setIconSize(20) // sets size of the icon.
.setIconDrawable(ContextCompat.getDrawable(context, R.drawable.ic_edit)) // sets a drawable resource.
```

### IconForm
`IconForm` has some attributes for `ImageView` to customize the icon of the Balloon. You can create the `IconForm` instance and reuse it on multiple Balloons.

```kotlin
val iconForm = IconForm.Builder(context)
  .setDrawable(ContextCompat.getDrawable(context, R.drawable.arrow))
  .setIconColor(ContextCompat.getColor(context, R.color.skyblue))
  .setIconSize(20)
  .setIconSize(12)
  .build()

val balloon = Balloon.Builder(context)
  .setIconForm(iconForm)
  ...
```

 Create IconForm with Kotlin DSL

You can create an instance of the `IconForm` with Kotlin DSL as the example below:

```kotlin
val iconForm = iconForm(context) {
  setDrawable(ContextCompat.getDrawable(context, R.drawable.arrow))
  setIconColor(ContextCompat.getColor(context, R.color.skyblue))
  setIconSize(20)
  setIconSize(12)
}

val balloon = Balloon.Builder(context)
  .setIconForm(iconForm)
  ...
```

 Create IconForm with Java

You can create an instance of the `IconForm` with Java as the example below:

```java
IconForm iconForm = new IconForm.Builder(context)
  .setDrawable(ContextCompat.getDrawable(context, R.drawable.arrow))
  .setIconColor(ContextCompat.getColor(context, R.color.skyblue))
  .setIconSize(20)
  .setIconSize(12)
  .build();

Balloon balloon = new Balloon.Builder(context)
  .setIconForm(iconForm)
  ...
```

### OnBalloonClickListener, OnBalloonDismissListener, OnBalloonOutsideTouchListener
We can listen to if the Balloon is clicked, dismissed, and touched outside with the below listeners.

```kotlin
.setOnBalloonClickListener { Toast.makeText(context, "clicked", Toast.LENGTH_SHORT).show() }
.setOnBalloonDismissListener { Toast.makeText(context, "dismissed", Toast.LENGTH_SHORT).show() }
.setOnBalloonOutsideTouchListener { Toast.makeText(context, "touched outside", Toast.LENGTH_SHORT).show() }
```

 Set Listeners with Java

You can set listeners with Java as the example below:

```java
balloon.setOnBalloonClickListener(new OnBalloonClickListener() {
  @Override
  public void onBalloonClick() {
    // doSomething;
  }
});

balloon.setOnBalloonDismissListener(new OnBalloonDismissListener() {
  @Override
  public void onBalloonDismiss() {
    // doSomething;
  }
});

balloon.setOnBalloonOutsideTouchListener(new OnBalloonOutsideTouchListener() {
  @Override
  public void onBalloonOutsideTouch() {
    // doSomething;
  }
});
```

### Custom Balloon Layout
You can fully customize the layout of the Balloon with the method below:

```kotlin
.setLayout(R.layout.my_balloon_layout)
```

You can build the Balloon with your own layout as the following example:

First, create your XML layout file like `layout_custom_profile` on your taste and set it on the  with `setLayout` method.

```kotlin
val balloon = Balloon.Builder(context)
  .setLayout(R.layout.layout_custom_profile)
  .setArrowSize(10)
  .setArrowOrientation(ArrowOrientation.TOP)
  .setArrowPosition(0.5f)
  .setWidthRatio(0.55f)
  .setHeight(250)
  .setCornerRadius(4f)
  .setBackgroundColor(ContextCompat.getColor(this, R.color.black))
  .setBalloonAnimation(BalloonAnimation.CIRCULAR)
  .setLifecycleOwner(lifecycleOwner)
  .build()
```

That's all. If you need to get Views or need some interactions, you can get your custom layout with the `getContentView()` method from your instance of the Balloon.

```kotlin
val button: Button =
  balloon.getContentView().findViewById(R.id.button_edit)
button.setOnClickListener {
  Toast.makeText(context, "Edit", Toast.LENGTH_SHORT).show()
  balloon.dismiss()
}
```

### Persistence
If you want to show up the Balloon only once or a specific number of times, you can implement it as the following example:

```kotlin
balloon.setPreferenceName("MyBalloon") // sets preference name of the Balloon.
balloon.setShowCounts(3) // show-up three of times the popup. the default value is 1.
balloon.runIfReachedShowCounts {
  // do something after the preference showing counts is reached the goal.
  }
```

Also, you can clear all persisted preferences with the method below:
```kotlin
balloon.clearAllPreferences()
```

### Avoid Memory leak
Dialog, PopupWindow etc, can have memory leak issues if not dismissed before the activity or fragment is destroyed.

But Lifecycles are now integrated with the Support Library since Architecture Components 1.0 Stable was released.

So we can solve the memory leak issue very easily like the below.

Just use `setLifecycleOwner` method. Then the `dismiss()` method will be called automatically before your activity or fragment would be destroyed.
```kotlin
.setLifecycleOwner(lifecycleOwner)
```

### Lazy initialization
You can initialize a property of the Balloon lazily with the `balloon()` extension and `Balloon.Factory` abstract class.

The `balloon()` extension keyword can be used on your `Activity`, `Fragment`, and `View`.

__Before__

`CustomActivity.kt`
```kotlin
class CustomActivity : AppCompatActivity() {
  private val profileBalloon by lazy { BalloonUtils.getProfileBalloon(context = this, lifecycleOwner = this) }

  // ...
}
```

__After__

`CustomActivity.kt`
```kotlin
class CustomActivity : AppCompatActivity() {
  private val profileBalloon by balloon<ProfileBalloonFactory>()

  // ...
}
```

We should create a class which extends `Balloon.Factory`.

An implementation class of the factory must have a default(non-argument) constructor.

`ProfileBalloonFactory.kt`
```kotlin
class ProfileBalloonFactory : Balloon.Factory() {

  override fun create(context: Context, lifecycle: LifecycleOwner): Balloon {
    return createBalloon(context) {
      setLayout(R.layout.layout_custom_profile)
      setArrowSize(10)
      setArrowOrientation(ArrowOrientation.TOP)
      setArrowPosition(0.5f)
      setWidthRatio(0.55f)
      setHeight(250)
      setCornerRadius(4f)
      setBackgroundColor(ContextCompat.getColor(context, R.color.background900))
      setBalloonAnimation(BalloonAnimation.CIRCULAR)
      setLifecycleOwner(lifecycle)
    }
  }
}
```

### BalloonOverlay
We can show up an overlay over the whole screen except an anchor view.

```kotlin
balloon.setIsVisibleOverlay(true) // sets the visibility of the overlay for highlighting an anchor.
balloon.setOverlayColorResource(R.color.overlay) // background color of the overlay using a color resource.
balloon.setOverlayPadding(6f) // sets a padding value of the overlay shape internally.
balloon.setOverlayPaddingColorResource(R.color.colorPrimary) // sets color of the overlay padding using a color resource.
balloon.setBalloonOverlayAnimation(BalloonOverlayAnimation.FADE) // default is fade.
balloon.setDismissWhenOverlayClicked(false) // disable dismissing the balloon when the overlay is clicked.
```

We can change the shape of the highlighting using the `.setOverlayShape` method.

```kotlin
balloon.setOverlayShape(BalloonOverlayOval) // default shape
balloon.setOverlayShape(BalloonOverlayRect)
balloon.setOverlayShape(BalloonOverlayCircle(radius = 36f))
balloon.setOverlayShape(BalloonOverlayRoundRect(12f, 12f))
```
OVAL | CIRCLE | RECT | ROUNDRECT |
| :---------------: | :---------------: | :---------------: | :---------------: |
|  |  |  |  |

Also, we can set the specific position of the overlay shape with the method below:
```kotlin
balloon.setOverlayPosition(Point(x, y)) // sets a specific position of the overlay shape.
```

### BalloonAnimation
We can implement popup animations while showing and dismissing.

```kotlin
BalloonAnimation.NONE
BalloonAnimation.FADE
BalloonAnimation.OVERSHOOT
BalloonAnimation.ELASTIC
BalloonAnimation.CIRCULAR
```

FADE | OVERSHOOT | ELASTIC | CIRCULAR |
| :---------------: | :---------------: | :---------------: | :---------------: |
|  |  |  |  |

### BalloonHighlightAnimation
We can give a repeated dynamic animations to the Balloon while it's showing up. The animation would work differently by the position of the arrow.

HEARTBEAT | SHAKE | BREATH | ROTATE |
| :---------------: | :---------------: | :---------------: | :---------------: |
|  |  |  |  |

```kotlin
BalloonHighlightAnimation.NONE
BalloonHighlightAnimation.HEARTBEAT
BalloonHighlightAnimation.SHAKE
BalloonHighlightAnimation.BREATH
BalloonHighlightAnimation.ROTATE

.setBalloonHighlightAnimation(BalloonHighlightAnimation.SHAKE)
```

We can implement the rotate animation like the example below:

```kotlin
.setBalloonHighlightAnimation(BalloonHighlightAnimation.ROTATE)
.setBalloonRotationAnimation(
        BalloonRotateAnimation.Builder().setLoops(2).setSpeeds(2500).setTurns(INFINITE).build())
```

## Balloon builder methods
For more details, you can check out the documentations below:
- [Balloon documentations](https://skydoves.github.io/libraries/balloon/html/balloon/com.skydoves.balloon/-balloon/index.html)
- [Builder documentations](https://skydoves.github.io/libraries/balloon/html/balloon/com.skydoves.balloon/-balloon/-builder/index.html)

## Balloon in Jetpack Compose

Balloon allows you to display tooltips in Jetpack Compose easily.

[![Maven Central](https://img.shields.io/maven-central/v/com.github.skydoves/balloon.svg?label=Maven%20Central)](https://search.maven.org/search?q=g:%22com.github.skydoves%22%20AND%20a:%22balloon%22)

Add the dependency below to your **module**'s `build.gradle` file:

```gradle
dependencies {
    implementation("com.github.skydoves:balloon-compose:$version")
}
```

### Balloon Composable

You can create and display tooltips using the `Balloon` composable function along with the `rememberBalloonBuilder`, as demonstrated in the following example:

```kotlin
// create and remember a builder of Balloon.
val builder = rememberBalloonBuilder {
  setArrowSize(10)
  setArrowPosition(0.5f)
  setArrowPositionRules(ArrowPositionRules.ALIGN_ANCHOR)
  setWidth(BalloonSizeSpec.WRAP)
  setHeight(BalloonSizeSpec.WRAP)
  setPadding(12)
  setMarginHorizontal(12)
  setCornerRadius(8f)
  setBackgroundColorResource(R.color.skyBlue)
  setBalloonAnimation(BalloonAnimation.ELASTIC)
}

Balloon(
  modifier = Modifier.align(Alignment.Center),
  builder = builder,
  balloonContent = {
    Text(text = "Now you can edit your profile!")
  }
) { balloonWindow ->
    Button(
      modifier = Modifier.size(120.dp, 75.dp),
      onClick = {
        balloonWindow.showAlignTop() // display your balloon.
     }
    ) {
      Text(text = "showAlignTop")
    }
}
```

### BalloonWindow

`BalloonWindow` is an interface defining all executable behaviors for a balloon's window, including showing, dismissing, updating, and setting up listeners. You can obtain an instance of `BalloonWindow` within the `content` parameter of the `Balloon` composable function, as illustrated in the example below:

```kotlin
Balloon(
  ..
) { balloonWindow ->
    Button(
      modifier = Modifier.size(120.dp, 75.dp),
      onClick = {
        balloonWindow.showAtCenter() // display your balloon.
     }
    ) {
      Text(text = "showAtCenter")
    }
}

Balloon(
  builder = builder,
  balloonContent = null
) { balloonWindow ->
  ..
}
```

You can also acquire the `BalloonWindow` by utilizing the `onBalloonWindowInitialized` lambda parameter in the `Balloon` composable. This parameter will be invoked just once when the `BalloonWindow` is fully prepared and ready for use:

```kotlin
var balloonWindow: BalloonWindow? by remember { mutableStateOf(null) }

Balloon(
  builder = builder,
  onBalloonWindowInitialized = { balloonWindow = it },
  balloonContent = {
    Text(text = "Now you can edit your profile!")
  },
) {
  Button(
    modifier = Modifier.size(160.dp, 60.dp),
    onClick = { balloonWindow?.showAlignTop() },
  ) {
    Text(text = "showAlignTop")
  }
}
```

The `onBalloonWindowInitialized` lambda paramter is useful when you need to hold an instance of the `BalloonWindow` as a state, and utilize it out of the `Balloon` composable function.

### Auto-Display Balloon on Layout Ready

To automatically show a Balloon when your layout is drawn, a common requirement in numerous applications, you can use the `onComposedAnchor` parameter within the `Balloon` composable function.

```kotlin
var balloonWindow: BalloonWindow? by remember { mutableStateOf(null) }

Balloon(
  builder = builder,
  onBalloonWindowInitialized = { balloonWindow = it },
  onComposedAnchor = { balloonWindow?.showAlignTop() },
  balloonContent = {
    Text(text = "Now you can edit your profile!")
  },
) {
  Button(
    modifier = Modifier.size(160.dp, 60.dp),
    onClick = { balloonWindow?.showAlignTop() },
  ) {
    Text(text = "showAlignTop")
  }
}
```

As you can see in the example above, you can use `onComposedAnchor` with the `onBalloonWindowInitialized` lambda to obtain the `BalloonWindow` and display your balloon sequentially after rendering your composable layout.

### Compose Extensions

The `balloon-compose` package provides useful compose extensions, such as setting a color with `androidx.compose.ui.graphics.Color` like the below:

```kotlin
val builder = rememberBalloonBuilder {
  setText("Now you can edit your profile!")
  setArrowSize(10)
  setWidthRatio(1.0f)
  setHeight(BalloonSizeSpec.WRAP)
  setArrowOrientation(ArrowOrientation.BOTTOM)
  setArrowPosition(0.5f)
  setPadding(12)
  setMarginHorizontal(12)
  setTextSize(15f)
  setCornerRadius(8f)
  setTextColor(Color.White) // set text color with compose color.
  setBackgroundColor(Color.White) // set background color with compose color.
  setIconDrawableResource(R.drawable.ic_edit)
}
```

> **Note**: If you want to use the default form of balloon (icon + text), you should pass a null value to the `balloonContent` parameter of your Balloon composable.

## Find this library useful? :heart:
Support it by joining __[stargazers](https://github.com/skydoves/balloon/stargazers)__ for this repository. :star:

Also, __[follow me](https://github.com/skydoves)__ on GitHub for my next creations! 🤩

# License
```xml
Copyright 2019 skydoves (Jaewoong Eum)

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
```


[](https://stripe.com/docs/mobile/android)

# Stripe Android SDK

[![CI](https://github.com/stripe/stripe-android/workflows/CI/badge.svg)](https://github.com/stripe/stripe-android/actions?query=workflow%3ACI)
[![GitHub release](https://img.shields.io/github/release/stripe/stripe-android.svg?maxAge=60)](https://github.com/stripe/stripe-android/releases)
[![License](https://img.shields.io/github/license/stripe/stripe-android)](https://github.com/stripe/stripe-android/blob/master/LICENSE)

> [!TIP]
> Want to chat live with Stripe engineers? Join us on our [Discord server](https://stripe.com/go/developer-chat).

The Stripe Android SDK makes it quick and easy to build an excellent payment experience in your Android app. We provide powerful and customizable UI elements that can be used out-of-the-box to collect your users' payment details. We also expose the low-level APIs that power those UIs so that you can build fully custom experiences.

Get started with our [📚 integration guides](https://stripe.com/docs/payments/accept-a-payment?platform=android) and [example projects](#examples), or [📘 browse the SDK reference](https://stripe.dev/stripe-android/).

> Updating to a newer version of the SDK? See our [migration guide](https://github.com/stripe/stripe-android/blob/master/MIGRATING.md) and [changelog](https://github.com/stripe/stripe-android/blob/master/CHANGELOG.md).

Table of contents
=================

   * [Features](#features)
   * [Releases](#releases)
   * [Installation](#installation)
      * [Requirements](#requirements)
      * [Configuration](#configuration)
   * [Getting Started](#getting-started)
   * [Examples](#examples)

## Features

**Simplified Security**: Use the SDK to collect credit card numbers and remain [PCI compliant](https://stripe.com/docs/security#pci-dss-guidelines). This means sensitive data is sent directly to Stripe instead of passing through your server. For more information, see our [Integration Security Guide](https://stripe.com/docs/security).

**SCA-Ready**: The SDK automatically performs native [3D Secure authentication](https://stripe.com/docs/payments/3d-secure) to comply with [Strong Customer Authentication](https://stripe.com/docs/strong-customer-authentication) regulation in Europe.

**Native UI**: We provide native screens and elements to collect payment. For example, [PaymentSheet](https://stripe.com/docs/payments/accept-a-payment?platform=android) is a prebuilt UI that combines all the steps required to pay - collecting payment details, and confirming the payment  - into a single sheet that displays on top of your app.

**Google Pay**: Stripe is fully compatible with [Google Pay](https://stripe.com/docs/google-pay).

**Stripe API**: We provide [low-level APIs](https://stripe.dev/stripe-android/payments-core/com.stripe.android/-stripe/index.html) that correspond to objects and methods in the Stripe API. You can build a custom UI on top of this layer.

**Localized**: We support the following localizations: Bulgarian, Catalan, Chinese (Hong Kong), Chinese (Simplified), Chinese (Traditional), Croatian, Czech, Danish, Dutch, English (US), English (United Kingdom), Estonian, Filipino, Finnish, French, French (Canada), German, Greek, Hungarian, Indonesian, Italian, Japanese, Korean, Latvian, Lithuanian, Malay, Maltese, Norwegian Bokmål, Norwegian Nynorsk (Norway), Polish, Portuguese, Portuguese (Brazil), Romanian, Russian, Slovak, Slovenian, Spanish, Spanish (Latin America), Swedish, Turkish, Thai and Vietnamese.

**Recommended usage**
If you're selling digital products or services that will be consumed within your app, (e.g. subscriptions, in-game currencies, game levels, access to premium content, or unlocking a full version), and you plan to distribute it through the Google Play Store, you must use Googles's in-app purchase APIs. See the [Google Play Billing](https://developer.android.com/distribute/play-billing) for more information. For all other scenarios you can use this SDK to process payments via Stripe.

## Releases
* The [changelog](CHANGELOG.md) provides a summary of changes in each release.
* The [migration guide](MIGRATING.md) provides instructions on upgrading from older versions.

## Installation

### Requirements

* Android 5.0 (API level 21) and above
* [Android Gradle Plugin](https://developer.android.com/studio/releases/gradle-plugin) 3.5.1
* [Gradle](https://gradle.org/releases/) 5.4.1+
* [AndroidX](https://developer.android.com/jetpack/androidx/) (as of v11.0.0)

### Configuration

Add `stripe-android` to your `build.gradle` dependencies.

```
dependencies {
    implementation 'com.stripe:stripe-android:20.46.0'
}
```

### Compatibility with Jetpack Compose

`stripe-android` uses Jetpack Compose internally and expects consumers to use a compatible version:

  20.22.0-20.31.0	Compose UI 1.4.x

  20.32.0-20.37.3	Compose UI 1.5.x

  20.37.4-Current	Compose UI 1.5.x or Compose UI 1.6.x

## Getting Started

### Integration
Get started with our [📚 integration guides](https://stripe.com/docs/payments/accept-a-payment?platform=android) and [example projects](#examples), or [📘 browse the SDK reference](https://stripe.dev/stripe-android/).

### Examples
- The [PaymentSheet example project](https://github.com/stripe/stripe-android/tree/master/paymentsheet-example) demonstrates how to integrate and use our prebuilt ui (single-step and multi-step).
- The [example project](https://github.com/stripe/stripe-android/tree/master/example) demonstrates other integrations, that give you more control over the user experience:
    - how to use the Stripe class's synchronous and asynchronous methods
    - how to use the CardFormView.


[![JetBrains team project](https://jb.gg/badges/team.svg)](https://confluence.jetbrains.com/display/ALL/JetBrains+on+GitHub)
[![CI](https://github.com/JetBrains/kotlin-wrappers/workflows/CI/badge.svg)](https://github.com/JetBrains/kotlin-wrappers/actions)
[![CI K2](https://github.com/JetBrains/kotlin-wrappers/workflows/CI-K2/badge.svg)](https://github.com/JetBrains/kotlin-wrappers/actions)
[![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-wrappers-bom)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-wrappers-bom)
[![Kotlin](https://img.shields.io/badge/kotlin-2.0.0-blue.svg?logo=kotlin)](http://kotlinlang.org)
[![Slack channel](https://img.shields.io/badge/chat-slack-green.svg?logo=slack)](https://kotlinlang.slack.com/messages/react/)

# Kotlin Wrappers

This repository hosts a number of [Kotlin](https://kotlinlang.org) wrappers for popular JavaScript libraries.

To learn more please refer to the `README`s of individual modules.

| README                                                                                |               Note               | Version                                                                                |
|:---------------------------------------------------------------------------------------|:--------------------------------:|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [kotlin-actions-toolkit](kotlin-actions-toolkit/README.md)                             |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-actions-toolkit)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-actions-toolkit)                             |
| [kotlin-browser](kotlin-browser/README.md)                                             |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-browser)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-browser)                                             |
| [kotlin-cesium-engine](kotlin-cesium-engine/README.md)                                 |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-cesium-engine)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-cesium-engine)                                 |
| [kotlin-cesium-widgets](kotlin-cesium-widgets/README.md)                               |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-cesium-widgets)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-cesium-widgets)                               |
| [kotlin-css](kotlin-css/README.md)                                                     |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-css)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-css)                                                     |
| [kotlin-cssom-core](kotlin-cssom-core/README.md)                                       |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-cssom-core)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-cssom-core)                                       |
| [kotlin-csstype](kotlin-csstype/README.md)                                             | [guide](./docs/guide/csstype.md) | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-csstype)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-csstype)                                             |
| [kotlin-electron](kotlin-electron/README.md)                                           |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-electron)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-electron)                                           |
| [kotlin-emotion](kotlin-emotion/README.md)                                             | [guide](./docs/guide/emotion.md) | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-emotion)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-emotion)                                             |
| [kotlin-extensions](kotlin-extensions/README.md)                                       |             archived             | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-extensions)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-extensions)                                       |
| [kotlin-js](kotlin-js/README.md)                                                       |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-js)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-js)                                                       |
| [kotlin-mui-material](kotlin-mui-material/README.md)                                   |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-mui-material)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-mui-material)                                   |
| [kotlin-mui-base](kotlin-mui-base/README.md)                                           |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-mui-base)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-mui-base)                                           |
| [kotlin-mui-icons-material](kotlin-mui-icons-material/README.md)                       |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-mui-icons-material)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-mui-icons-material)                       |
| [kotlin-mui-lab](kotlin-mui-lab/README.md)                                             |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-mui-lab)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-mui-lab)                                             |
| [kotlin-mui-system](kotlin-mui-system/README.md)                                       |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-mui-system)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-mui-system)                                       |
| [kotlin-muix-date-pickers](kotlin-muix-date-pickers/README.md)                         |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-muix-date-pickers)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-muix-date-pickers)                         |
| [kotlin-muix-tree-view](kotlin-muix-tree-view/README.md)                               |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-muix-tree-view)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-muix-tree-view)                               |
| [kotlin-node](kotlin-node/README.md)                                                   |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-node)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-node)                                                   |
| [kotlin-popper](kotlin-popper/README.md)                                               |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-popper)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-popper)                                               |
| [kotlin-preact-signals-core](kotlin-preact-signals-core/README.md)                     |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-preact-signals-core)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-preact-signals-core)                     |
| [kotlin-preact-signals-react](kotlin-preact-signals-react/README.md)                   |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-preact-signals-react)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-preact-signals-react)                   |
| [kotlin-react](kotlin-react/README.md)                                                 |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-react)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-react)                                                 |
| [kotlin-react-beautiful-dnd](kotlin-react-beautiful-dnd/README.md)                     |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-react-beautiful-dnd)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-react-beautiful-dnd)                     |
| [kotlin-react-core](kotlin-react-core/README.md)                                       |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-react-core)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-react-core)                                       |
| [kotlin-react-dom](kotlin-react-dom/README.md)                                         |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-react-dom)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-react-dom)                                         |
| [kotlin-react-dom-legacy](kotlin-react-dom-legacy/README.md)                           |             archived             | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-react-dom-legacy)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-react-dom-legacy)                           |
| [kotlin-react-dom-test-utils](kotlin-react-dom-test-utils/README.md)                   |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-react-dom-test-utils)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-react-dom-test-utils)                   |
| [kotlin-react-legacy](kotlin-react-legacy/README.md)                                   |             archived             | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-react-legacy)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-react-legacy)                                   |
| [kotlin-react-redux](kotlin-react-redux/README.md)                                     |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-react-redux)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-react-redux)                                     |
| [kotlin-react-router](kotlin-react-router/README.md)                                   |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-react-router)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-react-router)                                   |
| [kotlin-react-router-dom](kotlin-react-router-dom/README.md)                           |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-react-router-dom)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-react-router-dom)                           |
| [kotlin-react-popper](kotlin-react-popper/README.md)                                   |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-react-popper)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-react-popper)                                   |
| [kotlin-react-select](kotlin-react-select/README.md)                                   |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-react-select)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-react-select)                                   |
| [kotlin-react-use](kotlin-react-use/README.md)                                         |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-react-use)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-react-use)                                         |
| [kotlin-redux](kotlin-redux/README.md)                                                 |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-redux)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-redux)                                                 |
| [kotlin-remix-run-router](kotlin-remix-run-router/README.md)                           |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-remix-run-router)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-remix-run-router)                           |
| [kotlin-ring-ui](kotlin-ring-ui/README.md)                                             |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-ring-ui)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-ring-ui)                                             |
| [kotlin-styled-next](kotlin-styled-next/README.md)                                     |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-styled-next)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-styled-next)                                     |
| [kotlin-tanstack-query-core](kotlin-tanstack-query-core/README.md)                     |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-tanstack-query-core)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-tanstack-query-core)                     |
| [kotlin-tanstack-react-query](kotlin-tanstack-react-query/README.md)                   |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-tanstack-react-query)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-tanstack-react-query)                   |
| [kotlin-tanstack-react-query-devtools](kotlin-tanstack-react-query-devtools/README.md) |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-tanstack-react-query-devtools)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-tanstack-react-query-devtools) |
| [kotlin-tanstack-react-table](kotlin-tanstack-react-table/README.md)                   |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-tanstack-react-table)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-tanstack-react-table)                   |
| [kotlin-tanstack-react-virtual](kotlin-tanstack-react-virtual/README.md)               |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-tanstack-react-virtual)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-tanstack-react-virtual)               |
| [kotlin-tanstack-table-core](kotlin-tanstack-table-core/README.md)                     |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-tanstack-table-core)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-tanstack-table-core)                     |
| [kotlin-tanstack-virtual-core](kotlin-tanstack-virtual-core/README.md)                 |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-tanstack-virtual-core)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-tanstack-virtual-core)                 |
| [kotlin-typescript](kotlin-typescript/README.md)                                       |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-typescript)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-typescript)                                       |
| [kotlin-web](kotlin-web/README.md)                                                     |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-web)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-web)                                                     |
| [kotlin-wrappers-bom](kotlin-wrappers-bom/README.md)                                   |                                  | [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin-wrappers/kotlin-wrappers-bom)](https://mvnrepository.com/artifact/org.jetbrains.kotlin-wrappers/kotlin-wrappers-bom)                                   |

Artifacts are published to Maven Central, see the corresponding README files for package coordinates.

**All packages require JDK 8 to be installed.**

## Using In Your Projects

Use the "Kotlin Wrappers BOM" which helps to ensure consistency between the modules and allows you not to think
about version compatibility.

Just declare `kotlin-wrappers-bom` and specify the modules you need:

```kotlin
val kotlinWrappersVersion = "1.0.0-pre.761"

dependencies {
    implementation(platform("org.jetbrains.kotlin-wrappers:kotlin-wrappers-bom:$kotlinWrappersVersion"))
    implementation("org.jetbrains.kotlin-wrappers:kotlin-emotion")
    implementation("org.jetbrains.kotlin-wrappers:kotlin-react")
    implementation("org.jetbrains.kotlin-wrappers:kotlin-react-dom")
    implementation("org.jetbrains.kotlin-wrappers:kotlin-tanstack-react-table")
    // other wrappers
}
```

Or use a helper function:

```kotlin
fun kotlinw(target: String): String =
    "org.jetbrains.kotlin-wrappers:kotlin-$target"

val kotlinWrappersVersion = "1.0.0-pre.761"

dependencies {
    implementation(platform(kotlinw("wrappers-bom:$kotlinWrappersVersion")))
    implementation(kotlinw("emotion"))
    implementation(kotlinw("react"))
    implementation(kotlinw("react-dom"))
    implementation(kotlinw("tanstack-react-table"))
    // other wrappers
}
```

Make sure that you have `mavenCentral()` in the list of repositories.

## Examples

1. [To-do list example](examples/src/jsMain/kotlin/example/Todo.kt)

2. [Tic-Tac-Toe example](examples/src/jsMain/kotlin/example/TicTacToe.kt)

3. A port of "Thinking in React" [example](examples/src/jsMain/kotlin/example/Product.kt)

4. An [example of using axios](examples/src/jsMain/kotlin/example/AxiosSearch.kt) to fetch remote data. It also
   demonstrates how to add typings for an external library.

5. An [example of using Quill](examples/src/jsMain/kotlin/example/Quill.kt) that shows how to use an external React component.

6. An [example of using react-router-dom](examples/src/jsMain/kotlin/example/ReactRouterDom.kt) that shows how to use react-route-dom with hooks API.

7. [Building Web Applications with React and Kotlin/JS](https://play.kotlinlang.org/hands-on/Building%20Web%20Applications%20with%20React%20and%20Kotlin%20JS/01_Introduction), a tutorial by JetBrains.

8. [A full-stack demo application](https://github.com/mkraynov/kfsad) written in Kotlin for JetBrains Night Moscow 2019.

9. An [example of using react-table](https://github.com/karakum-team/kotlin-react-table-sample) that shows how to use react-table with hooks API.

10. An [example of using Material UI](https://github.com/karakum-team/kotlin-mui-showcase).

11. [ByteLegend](https://github.com/ByteLegend/ByteLegend): an open-source, real-world HTML5 MMORPG game.

Follow these examples to learn how to start developing your React apps with Kotlin. Good luck and have fun!

## Contributing

Contributions to this project are welcome! Please see the open
[issues](https://github.com/JetBrains/kotlin-wrappers/issues) or chat with us on the [#react](https://kotlinlang.slack.com/messages/react/) channel in our
[Slack](https://slack.kotlinlang.org/).


![Build Status](https://codebuild.eu-west-1.amazonaws.com/badges?uuid=eyJlbmNyeXB0ZWREYXRhIjoiekhxeERIMmNLSkNYUktnUFJzUVJucmJqWnFLMGlpNXJiNE1LLzVWV3B1QUpSSkhCS04veHZmUGxZZ0ZmZlRzYjJ3T1VtVEs1b3JxbWNVOHFOeFJDOTAwPSIsIml2UGFyYW1ldGVyU3BlYyI6ImZXNW5KaytDRGNLdjZuZDgiLCJtYXRlcmlhbFNldFNlcmlhbCI6MX0%3D&branch=master)
[![Coverage](https://img.shields.io/codecov/c/github/aws/aws-toolkit-jetbrains/master.svg)](https://codecov.io/gh/aws/aws-toolkit-jetbrains/branch/master)
[![Downloads](https://img.shields.io/jetbrains/plugin/d/11349-aws-toolkit.svg)](https://plugins.jetbrains.com/plugin/11349-aws-toolkit)
[![Version](https://img.shields.io/jetbrains/plugin/v/11349.svg?label=version)](https://plugins.jetbrains.com/plugin/11349-aws-toolkit)
[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=aws_aws-toolkit-jetbrains&metric=alert_status)](https://sonarcloud.io/dashboard?id=aws_aws-toolkit-jetbrains)

# AWS Toolkit for JetBrains

AWS Toolkit for JetBrains is a plugin for JetBrains IDEs that
make it easier to write applications built on [Amazon Web Services](https://aws.amazon.com/)

The AWS Toolkit for JetBrains is open source because we want you to be involved. We appreciate issues, feature requests, pull
requests, code reviews or any other contributions.

## Feedback

We want your feedback!

- Vote on [feature requests](https://github.com/aws/aws-toolkit-jetbrains/issues?q=is%3Aissue+is%3Aopen+label%3Afeature-request+sort%3Areactions-%2B1-desc). Votes help us drive prioritization of features
- [Request a new feature](https://github.com/aws/aws-toolkit-jetbrains/issues/new?labels=feature-request&template=feature_request.md)
- [Ask a question](https://github.com/aws/aws-toolkit-jetbrains/issues/new?labels=guidance&template=guidance_request.md)
- [File an issue](https://github.com/aws/aws-toolkit-jetbrains/issues/new?labels=bug&template=bug_report.md)
- Code contributions. See [our contributing guide](CONTRIBUTING.md) for how to get started.

## Supported IDEs
All JetBrains IDEs 2023.2+

## Installation

See [Installing the AWS Toolkit for JetBrains](https://docs.aws.amazon.com/console/toolkit-for-jetbrains/install) in the AWS Toolkit for JetBrains User Guide.

To use this AWS Toolkit, you will first need an AWS account, a user within that account, and an access key for that
user. To use the AWS Toolkit to do AWS serverless application development and to run/debug AWS Lambda functions locally,
you will also need to install the AWS CLI, Docker, and the AWS SAM CLI. The installation guide covers setting up all of
these prerequisites.

### EAP Builds
We also offer opt-in Early Access Preview builds that are built automatically.

In order to opt-in:
* Add the URL `https://plugins.jetbrains.com/plugins/eap/aws.toolkit` to your IDE's plugin repository preferences by
going to **Plugins->Gear Icon->Manage Plugin Repositories** and adding the URL to the list
* Check for updates.

### Installing From Source
Please see [CONTRIBUTING](CONTRIBUTING.md#building-from-source) for instructions.

## Features

### General

* **AWS Resource Explorer** - tree-view of AWS resources available in your
selected account/region. This does not represent all resources available in your account, only a sub-set of those
resource types supported by the plugin.
[Learn More](https://docs.aws.amazon.com/console/toolkit-for-jetbrains/aws-explorer)
* **Authentication** - Connect to AWS using static credentials, credential process, AWS Builder ID or AWS SSO. [Learn more about
authentication options](https://docs.aws.amazon.com/console/toolkit-for-jetbrains/credentials)

### Services

#### ![CloudFormation][cloudformation-icon] AWS CloudFormation
* View events, resources, and outputs for your CloudFormation stacks
#### ![CloudWatch Logs][cloudwatch-logs-icon] CloudWatch Logs
* View and search your CloudWatch log streams
#### ![AWS Lambda][lambda-icon] AWS Lambda

Many of these features require the [AWS SAM CLI](https://github.com/awslabs/aws-sam-cli) to be installed, see the
Serverless Application Model ([SAM](https://aws.amazon.com/serverless/sam/)) website for more information on
installation of the SAM CLI.

**SAM features support Java, Python, Node.js, and .NET Core**

* **Run/Debug Local Lambda Functions** - Locally test and step-through debug functions in a Lambda-like execution
environment provided by the SAM CLI.
[Learn More](https://docs.aws.amazon.com/console/toolkit-for-jetbrains/lambda-local)
* **Invoke Remote Lambda Functions** - Invoke remote functions using a sharable run-configuration
[Learn More](https://docs.aws.amazon.com/console/toolkit-for-jetbrains/lambda-remote)
* **Package & Deploy Lambda Functions** - Ability to package a Lambda function zip and create a remote lambda
[Learn More](https://docs.aws.amazon.com/console/toolkit-for-jetbrains/lambda-deploy)
* **Sync SAM-based Applications** - Sync & track SAM-based applications
[Learn More](https://docs.aws.amazon.com/console/toolkit-for-jetbrains/sam-deploy)

*Note: Python features are available in both PyCharm and IntelliJ with the
[Python Plugin](https://www.jetbrains.com/help/idea/plugin-overview.html) installed.*

#### ![Amazon Redshift][redshift-icon] Amazon RDS/Redshift
* Connect to RDS/Redshift databases using temporary credentials with IAM/SecretsManager, no copy paste required

*Note: database features require using a paid JetBrains product*
#### ![Amazon S3][s3-icon] Amazon S3
* View and manage your S3 buckets
* Upload/Download to from buckets
* [Learn more](https://docs.aws.amazon.com/console/toolkit-for-jetbrains/s3-tasks)

### Experimental Features

Sometimes we'll introduce experimental features that we're trying out. These may have bugs, usability problems or may not be fully functional, and because these
aren't ready for prime-time we'll hide them behind an experimental feature flag.

Experimental features can be enabled in the settings/preferences
(`Settings -> Tools -> AWS -> Experimental Features`) or via the Addtional Settings (![Gear Icon][gear-icon]) in the AWS Explorer Tool Window.

Please note that experimental features may be disabled / removed at any time.

## Licensing

The plugin is distributed according to the terms outlined in our [LICENSE](LICENSE).

[lambda-icon]: plugins/core/jetbrains-community/resources/icons/resources/LambdaFunction.svg
[s3-icon]: plugins/core/jetbrains-community/resources/icons/resources/S3Bucket.svg
[cloudwatch-logs-icon]: plugins/core/jetbrains-community/resources/icons/resources/cloudwatchlogs/CloudWatchLogs.svg
[cloudformation-icon]: plugins/core/jetbrains-community/resources/icons/resources/CloudFormationStack.svg
[redshift-icon]: plugins/core/jetbrains-community/resources/icons/resources/Redshift.svg
[find-action]: https://www.jetbrains.com/help/idea/searching-everywhere.html#search_actions
[gear-icon]: https://raw.githubusercontent.com/JetBrains/intellij-community/master/platform/icons/src/general/gear.svg


# Lets-Plot

[![official JetBrains project](http://jb.gg/badges/official-flat-square.svg)](https://confluence.jetbrains.com/display/ALL/JetBrains+on+GitHub)
[![License MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://raw.githubusercontent.com/JetBrains/lets-plot-kotlin/master/LICENSE)
[![Latest Release](https://img.shields.io/github/v/release/JetBrains/lets-plot)](https://github.com/JetBrains/lets-plot-kotlin/releases/latest)

**Lets-Plot** is a multiplatform plotting library built on the principles of the Grammar of Graphics.

The library' design is heavily influenced by Leland Wilkinson work [The Grammar of Graphics](https://www.goodreads.com/book/show/2549408.The_Grammar_of_Graphics) describing the deep features that underlie all statistical graphics.

> This grammar [...] is made up of a set of independent components that can be composed in many different ways. This makes [it] very powerful because you are not limited to a set of pre-specified graphics, but you can create new graphics that are precisely tailored for your problem.
> - Hadley Wickham, "[ggplot2: Elegant Graphics for Data Analysis](https://ggplot2-book.org/index.html)"

## Grammar of Graphics for Python [![Latest Release](https://badge.fury.io/py/lets-plot.svg)](https://pypi.org/project/lets-plot)

A bridge between R (ggplot2) and Python data visualization. \
To learn more see the documentation site at **[lets-plot.org](https://lets-plot.org)**.

## Grammar of Graphics for Kotlin [![Latest Release](https://img.shields.io/github/v/release/JetBrains/lets-plot-kotlin)](https://github.com/JetBrains/lets-plot-kotlin/releases/latest)

### Notebooks
Create plots in [Kotlin Notebook](https://plugins.jetbrains.com/plugin/16340-kotlin-notebook),
[Datalore](https://datalore.jetbrains.com/report/static/HZqq77cegYd.E7get_WnChZ/aTA9lQnPkRwdCzT6uy95GZ), [Jupyter with Kotlin Kernel](https://github.com/Kotlin/kotlin-jupyter#readme) \
or any other notebook that supports `Kotlin Kernel`. \
To learn more see the **[Lets-Plot Kotlin API](https://github.com/JetBrains/lets-plot-kotlin)** project at GitHub.

### Compose Multiplatform
Embed Lets-Plot charts in [Compose Multiplatform](https://github.com/JetBrains/compose-multiplatform) applications. \
To learn more see the **[Lets-Plot Skia Frontend](https://github.com/JetBrains/lets-plot-skia)** project at GitHub.

### JVM and Kotlin/JS
Embed Lets-Plot charts in JVM (Swing, JavaFX) and Kotlin/JS applications.

To learn more see the **[Lets-Plot Kotlin API](https://github.com/JetBrains/lets-plot-kotlin)** project at GitHub.

## "Lets-Plot in SciView" plugin

[![JetBrains Plugins](https://img.shields.io/jetbrains/plugin/v/14379-lets-plot-in-sciview.svg)](http://plugins.jetbrains.com/plugin/14379-lets-plot-in-sciview)
[![JetBrains plugins](https://img.shields.io/jetbrains/plugin/d/14379-lets-plot-in-sciview.svg)](http://plugins.jetbrains.com/plugin/14379-lets-plot-in-sciview)

*Scientific mode* in PyCharm and in IntelliJ IDEA provides support for interactive scientific computing and data visualization.

[*Lets-Plot in SciView*](https://plugins.jetbrains.com/plugin/14379-lets-plot-in-sciview) plugin adds
support for interactive plotting to IntelliJ-based IDEs with the *Scientific mode* enabled.

>
> **Note:** The *Scientific mode* is NOT available in communinty editions of JetBrains IDEs.
>

Also read:

- [Scientific mode in PyCharm](https://www.jetbrains.com/help/pycharm/matplotlib-support.html)
- [Scientific mode in IntelliJ IDEA](https://www.jetbrains.com/help/idea/matplotlib-support.html)

## What is new in 4.3.0

- #### `coord_polar()`

    The polar coordinate system is most commonly used for pie charts, but

    it can also be used for constructing **Spider or Radar charts** using the `flat` option.

    See: [example notebook](https://nbviewer.org/github/JetBrains/lets-plot/blob/master/docs/f-24a/coord_polar.ipynb).

- #### In the `theme()`:

    - `panel_inset`  parameter - primarily used for plots with polar coordinates.

        See: [example notebook](https://nbviewer.org/github/JetBrains/lets-plot/blob/master/docs/f-24a/theme_panel_inset.ipynb).

    - `panel_border_ontop` parameter - enables the drawing of panel border on top of the plot geoms.
    - `panel_grid_ontop, panel_grid_ontop_x, panel_grid_ontop_y` parameters - enable the drawing of grid lines on top of the plot geoms.

- #### `geom_curve()`

    See: [example notebook](https://nbviewer.org/github/JetBrains/lets-plot/blob/master/docs/f-24a/geom_curve.ipynb).

- #### [**UNIQUE**] Visualizing Graph-like Data with `geom_segment()` and `geom_curve()`

  - Aesthetics `size_start, size_end, stroke_start` and `stroke_end` enable better alignment of

    segments/curves with nodes of the graph by considering the size of the nodes.

  - The `spacer` parameter allows for additional manual fine-tuning.

  See:
  - [A simple graph example](https://nbviewer.org/github/JetBrains/lets-plot/blob/master/docs/f-24a/graph_edges.ipynb)
  - [An interactive map example](https://nbviewer.org/github/JetBrains/lets-plot/blob/master/docs/f-24a/geom_curve_on_map.ipynb)

- #### The `alpha_stroke` Parameter in `geom_label()`

  Use the `alpha_stroke` parameter to apply `alpha` to entire `label`. By default, `alpha` is only applied to the label background.

  See: [example notebook](https://nbviewer.org/github/JetBrains/lets-plot/blob/master/docs/f-24a/geom_label_alpha_stroke.ipynb).

- #### Showing Plots in External Browser

  The [setup_show_ext()](https://lets-plot.org/python/pages/api/lets_plot.LetsPlot.html#lets_plot.LetsPlot.setup_show_ext) directive allows plots to be displayed in an external browser window.

## Recent Updates in the [Gallery](https://lets-plot.org/python/pages/gallery.html)

## Change Log

See [CHANGELOG.md](https://github.com/JetBrains/lets-plot/blob/master/CHANGELOG.md) for other changes and fixes.

## Code of Conduct

This project and the corresponding community are governed by the
[JetBrains Open Source and Community Code of Conduct](https://confluence.jetbrains.com/display/ALL/JetBrains+Open+Source+and+Community+Code+of+Conduct).
Please make sure you read it.

## License

Code and documentation released under the [MIT license](https://github.com/JetBrains/lets-plot/blob/master/LICENSE).
Copyright © 2019-2024, JetBrains s.r.o.


![GitHub Workflow Status (branch)](https://img.shields.io/github/actions/workflow/status/Hannah-Sten/TeXiFy-IDEA/main.yml?branch=master&style=flat-square)
[![Version](https://img.shields.io/jetbrains/plugin/v/9473-texify-idea.svg?style=flat-square)](https://plugins.jetbrains.com/plugin/9473-texify-idea)
[![View at JetBrains](https://img.shields.io/jetbrains/plugin/d/9473-texify-idea.svg?style=flat-square)](https://plugins.jetbrains.com/plugin/9473-texify-idea)
![JetBrains IntelliJ Plugins](https://img.shields.io/jetbrains/plugin/r/rating/9473-texify-idea?style=flat-square)
[![Join the chat at https://app.gitter.im/#/room/#TeXiFy-IDEA_Support:gitter.im](https://img.shields.io/badge/gitter-join%20chat-green.svg?style=flat-square)](https://app.gitter.im/#/room/#TeXiFy-IDEA_Support:gitter.im)
[![Donate via PayPal](https://img.shields.io/badge/Donate!-PayPal-orange.png?style=flat-square)](https://www.paypal.me/HannahSchellekens)
[![codecov](https://img.shields.io/codecov/c/github/Hannah-Sten/TeXiFy-IDEA/master?style=flat-square)](https://codecov.io/gh/Hannah-Sten/TeXiFy-IDEA)
[![Average time to resolve an issue](http://isitmaintained.com/badge/resolution/Hannah-Sten/TeXiFy-IDEA.svg)](http://isitmaintained.com/project/Hannah-Sten/TeXiFy-IDEA "Average time to resolve an issue")
[![Percentage of issues still open](http://isitmaintained.com/badge/open/Hannah-Sten/TeXiFy-IDEA.svg)](http://isitmaintained.com/project/Hannah-Sten/TeXiFy-IDEA "Percentage of issues still open")

# TeXiFy-IDEA
(Pronounced as `/ˈtɛxɪfaɪ aɪˈdɪə/` with a greek letter Chi (χ), just as in LaTeX)

LaTeX support for the IntelliJ Platform by [JetBrains](https://www.jetbrains.com/).

Read the [Quick Start guide](https://hannah-sten.github.io/TeXiFy-IDEA/quick-start-guide.html) to get started directly.
No idea where to start, or new to LaTeX or IntelliJ? Have a look at the [installation guide](https://hannah-sten.github.io/TeXiFy-IDEA/installation-guide.html), or browse through the [documentation](https://hannah-sten.github.io/TeXiFy-IDEA).

Create the most beautiful LaTeX documents with the user friendliness of the IntelliJ platform.
This plugin adds the tools to make creating LaTeX documents a breeze. We are currently doing our best to develop the plugin.

## Feedback and support
You can share new ideas/feature requests/bugs/calls for help in multiple ways:
1. For questions, ideas or general comments use the [Discussions tab](https://github.com/Hannah-Sten/TeXiFy-IDEA/discussions/categories/q-a) to start a new discussion.
2. [Issues](https://github.com/Hannah-Sten/TeXiFy-IDEA/issues). These may be bug reports, feature requests, etc. Just generally anything you have a problem with/suggestion for. For general feedback we advise to use GitHub Discussions.
3. Live chat via [gitter](https://app.gitter.im/#/room/#TeXiFy-IDEA_Support:gitter.im) (you can login with your GitHub account).

Please bear in mind that this is just a side project for us. It might take a while to fully process your feedback. We try our best :3

## Contributing
We would love it if you want to contribute to this project!
Please have a look at the [contributing guidelines](CONTRIBUTING.md) to get started.

## Features

* [Syntax highlighting](https://hannah-sten.github.io/TeXiFy-IDEA/editor.html#color-scheme)
* [Autocompletion of labels, (custom defined) commands and environments](https://hannah-sten.github.io/TeXiFy-IDEA/code-completion.html)
* [Writer ergonomics - writing LaTeX made less cumbersome](https://www.jetbrains.com/idea/features/)
* [Compiler support for pdfLaTeX, LuaTeX, Latexmk, texliveonfly, XeLaTeX, bibtex, and biber](https://hannah-sten.github.io/TeXiFy-IDEA/run-configuration-settings.html#latex-compilers)
* [Inspections. Intentions. And heaps more inspections](https://hannah-sten.github.io/TeXiFy-IDEA/inspections.html)
* [Full BibTeX support](https://hannah-sten.github.io/TeXiFy-IDEA/bibtex.html)
* [Formatter for LaTeX and BibTeX](https://hannah-sten.github.io/TeXiFy-IDEA/code-formatting.html)
* [Structure view for LaTeX and BibTeX with filters](https://hannah-sten.github.io/TeXiFy-IDEA/code-navigation.html#structure-view)
* [Code folding for imports, sections, and environments](https://hannah-sten.github.io/TeXiFy-IDEA/general.html#code-folding)
* [Built-in pdf viewer via the PDF Viewer plugin, including forward and backward search](https://hannah-sten.github.io/TeXiFy-IDEA/pdf-viewers.html#pdf-viewer-intellij-plugin)
* [SumatraPDF (Windows)](https://hannah-sten.github.io/TeXiFy-IDEA/pdf-viewers.html#sumatrapdf), [Evince (Linux)](https://hannah-sten.github.io/TeXiFy-IDEA/pdf-viewers.html#evince), [Okular (Linux)](https://hannah-sten.github.io/TeXiFy-IDEA/pdf-viewers.html#okular), [Zathura (Linux)](https://hannah-sten.github.io/TeXiFy-IDEA/pdf-viewers.html#zathura) and [Skim (MacOS)](https://hannah-sten.github.io/TeXiFy-IDEA/pdf-viewers.html#skim) support with forward and backward search
* [Smart Quotes](https://hannah-sten.github.io/TeXiFy-IDEA/texify-settings.html#smart-quote-substitution)
* [Unicode math preview](https://hannah-sten.github.io/TeXiFy-IDEA/general.html#unicode-math-preview)
* [Equation preview](https://hannah-sten.github.io/TeXiFy-IDEA/tool-windows.html#equation-preview)
* [Gutter icons for quick compilation and file includes](https://hannah-sten.github.io/TeXiFy-IDEA/running-a-latex-file.html#gutter-icons)
* [Fancy icons that fit in with the IntelliJ style](https://hannah-sten.github.io/TeXiFy-IDEA/editing-a-latex-file.html)
* [Brace matching](https://hannah-sten.github.io/TeXiFy-IDEA/code-completion.html#brace-matching)
* [Word counting tool](https://hannah-sten.github.io/TeXiFy-IDEA/tools.html#word-counting-tool)
* [File templates for .tex, .sty, .cls and .bib files](https://hannah-sten.github.io/TeXiFy-IDEA/editor.html#file-templates)
* [Automagically import packages of common commands](https://hannah-sten.github.io/TeXiFy-IDEA/editing-a-latex-file.html#automatic-package-importing)
* [Go to declaration](https://hannah-sten.github.io/TeXiFy-IDEA/code-navigation.html#go-to-declaration-for-labels-citations-and-commands) and [find usages](https://hannah-sten.github.io/TeXiFy-IDEA/code-navigation.html#find-usages) for labels, citations, and custom commands
* [Renaming of labels, citations, environments and files](https://hannah-sten.github.io/TeXiFy-IDEA/editing-a-latex-file.html#renaming-labels-and-environments)
* [Shortcuts for styling text](https://hannah-sten.github.io/TeXiFy-IDEA/editing-a-latex-file.html#styling-text)
* [Line commenter](https://hannah-sten.github.io/TeXiFy-IDEA/editing-a-latex-file.html#line-commenting)
* [Support for user-created commands, document classes and packages](https://hannah-sten.github.io/TeXiFy-IDEA/editing-a-latex-file.html#support-for-user-defined-commands)

The full documentation can be found at https://hannah-sten.github.io/TeXiFy-IDEA
You can find IntelliJ documentation at https://www.jetbrains.com/idea/documentation/ and https://www.jetbrains.com/help/idea/.

## Installation instructions and getting started

See the [quick start guide](https://hannah-sten.github.io/TeXiFy-IDEA/quick-start-guide.html) or the [full installation guide](https://hannah-sten.github.io/TeXiFy-IDEA/installation-guide.html) for how to install everything you need to get up and running with TeXiFy-IDEA.

## Other helpful links

* [Troubleshooting issues with TeXiFy-IDEA](https://hannah-sten.github.io/TeXiFy-IDEA/troubleshooting.html)
* [Editing the documentation](https://hannah-sten.github.io/TeXiFy-IDEA/contributing-to-the-documentation.html)
* [Installing pre-release builds](https://hannah-sten.github.io/TeXiFy-IDEA/installing-pre-release-builds.html) for the latest features.
* [Building the project from source](https://hannah-sten.github.io/TeXiFy-IDEA/contributing-to-the-source-code.html)

## Screenshots

![](https://plugins.jetbrains.com/files/9473/screenshot_19301.png)

![](https://plugins.jetbrains.com/files/9473/screenshot_19302.png)

![](https://plugins.jetbrains.com/files/9473/screenshot_19303.png)

![](https://plugins.jetbrains.com/files/9473/screenshot_19304.png)

![](https://plugins.jetbrains.com/files/9473/screenshot_19305.png)

![](https://plugins.jetbrains.com/files/9473/screenshot_19306.png)

![](https://plugins.jetbrains.com/files/9473/screenshot_19307.png)

![](https://plugins.jetbrains.com/files/9473/screenshot_19308.png)

![](https://plugins.jetbrains.com/files/9473/screenshot_19309.png)


![OSS Review Toolkit Logo](./logos/ort.png)

[![Slack][1]][2]

[![Wrapper Validation][3]][4] [![Static Analysis][5]][6]

[![Build and Test][7]][8] [![JitPack build status][9]][10] [![Code coverage][11]][12]

[![TODOs][13]][14] [![REUSE status][15]][16] [![OpenSSF Best Practices][17]][18]

[1]: https://img.shields.io/badge/Join_us_on_Slack!-ort--talk-blue.svg?longCache=true&logo=slack
[2]: http://slack.oss-review-toolkit.org
[3]: https://github.com/oss-review-toolkit/ort/actions/workflows/wrapper-validation.yml/badge.svg
[4]: https://github.com/oss-review-toolkit/ort/actions/workflows/wrapper-validation.yml
[5]: https://github.com/oss-review-toolkit/ort/actions/workflows/static-analysis.yml/badge.svg
[6]: https://github.com/oss-review-toolkit/ort/actions/workflows/static-analysis.yml
[7]: https://github.com/oss-review-toolkit/ort/actions/workflows/build-and-test.yml/badge.svg
[8]: https://github.com/oss-review-toolkit/ort/actions/workflows/build-and-test.yml
[9]: https://jitpack.io/v/oss-review-toolkit/ort.svg
[10]: https://jitpack.io/#oss-review-toolkit/ort
[11]: https://codecov.io/gh/oss-review-toolkit/ort/branch/main/graph/badge.svg?token=QD2tCSUTVN
[12]: https://app.codecov.io/gh/oss-review-toolkit/ort
[13]: https://badgen.net/https/api.tickgit.com/badgen/github.com/oss-review-toolkit/ort
[14]: https://www.tickgit.com/browse?repo=github.com/oss-review-toolkit/ort
[15]: https://api.reuse.software/badge/github.com/oss-review-toolkit/ort
[16]: https://api.reuse.software/info/github.com/oss-review-toolkit/ort
[17]: https://www.bestpractices.dev/projects/4618/badge
[18]: https://www.bestpractices.dev/projects/4618

# Introduction

The OSS Review Toolkit (ORT) is a FOSS policy automation and orchestration toolkit that you can use to manage your (open source) software dependencies in a strategic, safe and efficient manner.

You can use it to:

* Generate CycloneDX, SPDX SBOMs, or custom FOSS attribution documentation for your software project
* Automate your FOSS policy using risk-based Policy as Code to do licensing, security vulnerability, InnerSource and engineering standards checks for your software project and its dependencies
* Create a source code archive for your software project and its dependencies to comply with certain licenses or have your own copy as nothing on the internet is forever
* Correct package metadata or licensing findings yourself, using InnerSource or with the help of the FOSS community

ORT can be used as a library (for programmatic use), via a command line interface (for scripted use), or via its CI integrations.
It consists of the following tools which can be combined into a *highly customizable* pipeline:

* [*Analyzer*](https://oss-review-toolkit.org/ort/docs/tools/analyzer):
  Determines the dependencies of projects and their metadata, abstracting which package managers or build systems are actually being used.
* [*Downloader*](https://oss-review-toolkit.org/ort/docs/tools/downloader):
  Fetches all source code of the projects and their dependencies, abstracting which Version Control System (VCS) or other means are used to retrieve the source code.
* [*Scanner*](https://oss-review-toolkit.org/ort/docs/tools/scanner):
  Uses configured source code scanners to detect license / copyright findings, abstracting the type of scanner.
* [*Advisor*](https://oss-review-toolkit.org/ort/docs/tools/advisor):
  Retrieves security advisories for used dependencies from configured vulnerability data services.
* [*Evaluator*](https://oss-review-toolkit.org/ort/docs/tools/evaluator):
  Evaluates custom policy rules along with custom license classifications against the data gathered in preceding stages and returns a list of policy violations, e.g. to flag license findings.
* [*Reporter*](https://oss-review-toolkit.org/ort/docs/tools/reporter):
  Presents results in various formats such as visual reports, Open Source notices or Bill-Of-Materials (BOMs) to easily identify dependencies, licenses, copyrights or policy rule violations.
* *Notifier*:
  Sends result notifications via different channels (like [emails](./examples/example.notifications.kts) and / or JIRA tickets).

Also see the [list of related tools](https://oss-review-toolkit.org/ort/docs/related-tools) that help with running ORT.

## Documentation

For detailed information, see the documentation on the [ORT Website](https://oss-review-toolkit.org/ort/).

# Installation

## System requirements

ORT is being continuously used on Linux, Windows and macOS by the [core development team](https://github.com/orgs/oss-review-toolkit/people), so these operating systems are considered to be well-supported.

To run the ORT binaries (also see [Installation from binaries](#from-binaries)) at least Java 11 is required.
Memory and CPU requirements vary depending on the size and type of project(s) to analyze / scan, but the general recommendation is to configure Java with 8 GiB of memory and to use a CPU with at least 4 cores.

```shell
# This will give the Java Virtual Machine 8GB Memory.
export JAVA_OPTS="$JAVA_OPTS -Xmx8g"
```

If ORT requires external tools to analyze a project, these tools are listed by the `ort requirements` command.
If a package manager is not list listed there, support for it is integrated directly into ORT and does not require any external tools to be installed.

## From binaries

Preliminary binary artifacts for ORT are currently available via [JitPack](https://jitpack.io/#oss-review-toolkit/ort).
Please note that due to limitations with the JitPack build environment, the reporter is not able to create the Web App report.

## From sources

Install the following basic prerequisites:

* Git (any recent version will do).

Then clone this repository.

```shell
git clone https://github.com/oss-review-toolkit/ort
# If you intend to run tests, you have to clone the submodules too.
cd ort
git submodule update --init --recursive
```

### Build using Docker

Install the following basic prerequisites:

* Docker 18.09 or later (and ensure its daemon is running).
* Enable [BuildKit](https://docs.docker.com/develop/develop-images/build_enhancements/#to-enable-buildkit-builds) for Docker.

Change into the directory with ORT's source code and run `docker build -t ort .`.
Alternatively, use the script at `scripts/docker_build.sh` which also sets the ORT version from the Git revision.

### Build natively

Install these additional prerequisites:

* Java Development Kit (JDK) version 11 or later; also remember to set the `JAVA_HOME` environment variable accordingly.

Change into the directory with ORT's source code and run `./gradlew installDist` (on the first run this will bootstrap Gradle and download all required dependencies).

## Basic usage

Depending on how ORT was installed, it can be run in the following ways:

* If the Docker image was built, use

  ```shell
  docker run ort --help
  ```

  You can find further hints for using ORT with Docker in the [documentation](./website/docs/guides/docker.md).

* If the ORT distribution was built from sources, use

  ```shell
  ./cli/build/install/ort/bin/ort --help
  ```

* If running directly from sources via Gradle, use

  ```shell
  ./gradlew cli:run --args="--help"
  ```

  Note that in this case the working directory used by ORT is that of the `cli` project, not the directory `gradlew` is located in (see https://github.com/gradle/gradle/issues/6074).

# Want to Help or have Questions?

All contributions are welcome.
If you are interested in contributing, please read our [contributing guide](https://github.com/oss-review-toolkit/.github/blob/main/CONTRIBUTING.md).
To get quick answers to any of your questions, we recommend you [join our Slack community][2].

# License

Copyright (C) 2017-2024 [The ORT Project Authors](./NOTICE).

See the [LICENSE](./LICENSE) file in the root of this project for license details.

OSS Review Toolkit (ORT) is a [Linux Foundation project](https://www.linuxfoundation.org) and part of [ACT](https://automatecompliance.org/).


![Kotest](doc/logo7-with-text.png)
==========

[![master](https://github.com/kotest/kotest/actions/workflows/master.yml/badge.svg)](https://github.com/kotest/kotest/actions/workflows/master.yml)
[](https://search.maven.org/search?q=g:io.kotest%20OR%20g:io.kotest)
![intellij-badge](https://img.shields.io/jetbrains/plugin/v/14080-kotest?label=intellij%20plugin)
![GitHub](https://img.shields.io/github/license/kotest/kotest)
[![kotest @ kotlinlang.slack.com](https://img.shields.io/static/v1?label=kotlinlang&message=kotest&color=blue&logo=slack)](https://kotlinlang.slack.com/archives/CT0G9SD7Z)
[![Average time to resolve an issue](https://isitmaintained.com/badge/resolution/kotest/kotest.svg)](https://isitmaintained.com/project/kotest/kotest "Average time to resolve an issue")
[](https://s01.oss.sonatype.org/content/repositories/snapshots/io/kotest/)

__Kotest is a flexible and comprehensive testing tool for [Kotlin](https://kotlinlang.org/) with multiplatform support.__

To learn more about Kotest, visit [kotest.io](https://kotest.io) or see our [quick start](https://kotest.io/docs/quickstart/) guide.
Looking to upgrade? - see the [changelog](https://kotest.io/docs/next/changelog.html)

Community
---------
* [Kotest channel](https://kotlinlang.slack.com/messages/kotest) in the Kotlin Slack (get an invite [here](https://slack.kotlinlang.org/))
* [Stack Overflow](https://stackoverflow.com/questions/tagged/kotest) (don't forget to use the tag "kotest".)
* [Contribute](https://github.com/kotest/kotest/blob/master/CONTRIBUTING.md)
* [Blogs and articles](https://kotest.io/docs/blogs/).

![Yourkit Logo](https://www.yourkit.com/images/yklogo.png)

YourKit supports open source projects with innovative and intelligent tools
for monitoring and profiling Java and .NET applications.
YourKit is the creator of YourKit Java Profiler,
YourKit .NET Profiler,
and YourKit YouMonitor.


![logo](/snapshot/logo.png)
# EmmyLua for IntelliJ IDEA

[![Build status](https://github.com/EmmyLua/IntelliJ-EmmyLua/actions/workflows/build.yml/badge.svg?branch=master)](https://github.com/EmmyLua/IntelliJ-EmmyLua/actions/workflows/build.yml)
[![Online EmmyLua Doc](https://img.shields.io/badge/emmy-doc-46BC99.svg?style=flat-square)](https://emmylua.github.io)
[![在线文档](https://img.shields.io/badge/emmy-中文-46BC99.svg?style=flat-square)](https://emmylua.github.io/zh_CN)
[![Jetbrains plugin](https://img.shields.io/jetbrains/plugin/d/9768-emmylua.svg?style=flat-square)](https://plugins.jetbrains.com/plugin/9768-emmylua)
[![Jetbrains plugin](https://img.shields.io/jetbrains/plugin/v/9768-emmylua.svg?style=flat-square)](https://plugins.jetbrains.com/plugin/9768-emmylua)
[![donate](https://img.shields.io/badge/donate-emmy-FF69B4.svg?style=flat-square)](https://emmylua.github.io/donate.html)
[![Join the chat at gitter](https://img.shields.io/badge/chat-on%20gitter-46BC99.svg?style=flat-square)](https://gitter.im/emmylua/Lobby?utm_source=share-link&utm_medium=link&utm_campaign=share-link)
[![加入QQ群](https://img.shields.io/badge/chat-QQ(1)群-46BC99.svg?style=flat-square)](https://jq.qq.com/?_wv=1027&k=5Br83i5)
[![加入QQ群](https://img.shields.io/badge/chat-QQ(2)群-46BC99.svg?style=flat-square)](https://jq.qq.com/?_wv=1027&k=5EeI0Sm)

QQ交流群：1群：`29850775` 2群：`529914962`
(最新版本以及部分视频演示在群文件中下载)

![snapshot](/snapshot/overview.gif)

## Find usages
![find_usages](/snapshot/find_usages.gif)

## Rename
![rename](/snapshot/rename.gif)

## Parameter hints
![param_hints](/snapshot/param_hints.png)
![param_hints_cfg](/snapshot/param_hints_cfg.png)

## Go to symbol
![go_to_symbol](/snapshot/go_to_symbol.gif)

## Go to class
![go_to_class](/snapshot/go_to_class.gif)

## Quick Documentation(Ctrl + Q)
![quick_documentation](/snapshot/quick_documentation.gif)

## Method separators
![method_separators_cfg](/snapshot/method_separators_cfg.png)
![method_separators](/snapshot/method_separators.png)

## Method override line marker
![method_override_line_marker](/snapshot/method_override_line_marker.gif)

## Features
| feature                              | progress |
| ------------------------------------ | :------: |
| Syntax highlighting                  |    ✔     |
| Highlighting global                  |    ✔     |
| Highlighting local/param             |    ✔     |
| Highlighting up value                |    ✔     |
| Lua 5.3 support                      |    ✔     |
| Find usages                          |    ✔     |
| Rename(Shift + F6)                   |    ✔     |
| Go to definition(Ctrl + Mouse)       |    ✔     |
| Go to symbol(Ctrl + Alt + Shift + N) |    ✔     |
| Go to class(Ctrl + N)                |    ✔     |
| Go to file(Ctrl + Shift + N)         |    ✔     |
| Parameter name hints                 |    ✔     |
| Keyword completion                   |    ✔     |
| Basic completion                     |    ✔     |
| Structure view                       |    ✔     |
| Brace Matching                       |    ✔     |
| Comment in/out                       |    ✔     |
| Color settings page                  |    ✔     |
| Comment based type/class annotation  |    ✔     |
| Method override line marker          |    ✔     |
| Name suggestion for refactor         |    ✔     |
| Quick Documentation(Ctrl + Q)        |    ✔     |
| Live templates                       |    ✔     |
| Postfix completion templates         |    14    |
| Code formatter                       |    ✔     |
| Code intentions                      |    9     |
| Code inspections                     |    7     |
| Lua Standard Library/API             |    ✔     |
| Region folding                       |    ✔     |
| Attach Debugger                      |    ✔     |
| Remote Debugger                      |    ✔     |
| Lua Check                            |    ✔     |
| Embed Remote Debugger                |    0%    |
| Lua Profiler                         |    ✔     |
| ... .etc                             |          |

## Road map
- [ ] Attach debugger rewriting
- [x] Remote debugger rewriting
- [ ] Data follow inspections
- [ ] Ctrl follow inspections
- [ ] `@interface` support
- [ ] API Hub

## Build environment requirements

- JDK 11
- Setup environment variables as following:

        JAVA_HOME="path to JDK 11"
        IDEA_HOME_203="path to IDEA 203+"

## Building

  `./gradlew buildPlugin -DIDEA_VER=203`

## Developed By

[**@tangzx** 阿唐](https://github.com/tangzx)

**Contributors**
- [**@dsmgit** dsmgit](https://github.com/dsmgit)
- [**@Perryvw** Perry van Wesel](https://github.com/Perryvw)
- [**@ice1000** Tesla Ice Zhang](https://github.com/ice1000)
- [**@mqualizz** Marco Qualizza](https://github.com/mqualizz)
- [**@jb574** jb574](https://github.com/jb574)
- [**@luchuanbaker** luchuanbaker](https://github.com/luchuanbaker)
- [**@LiamYao** Yao](https://github.com/LiamYao)
- [**@Dauch** Tyler Dauch](https://github.com/Dauch)
- [**@Christopher-St** Christopher-St](https://github.com/Christopher-St)
- [**@taigacon** taigacon](https://github.com/taigacon)
- [**@KKKIIO** KKKIIO](https://github.com/KKKIIO)
- [**@zj6882917** zj6882917](https://github.com/zj6882917)
- [**@fangfang1984** fangfang1984](https://github.com/fangfang1984)


# Strikt

Strikt is an assertion library for Kotlin intended for use with a test runner such as [JUnit](https://junit.org/junit5/), [Minutest](https://github.com/dmcg/minutest), [Spek](http://spekframework.org/), or [KotlinTest](https://github.com/kotlintest/kotlintest).

Strikt uses a fluent assertion style similar to [AssertJ](https://assertj.github.io/doc/) but leverages Kotlin's type system and extension functions rather than needing a complex hierarchy of assertion builder classes.

Strikt is under development, but 100% usable.
The API may change until a [version 1.0](https://github.com/robfletcher/strikt/milestone/1) is released.
Any suggestions, [issue reports](https://github.com/robfletcher/strikt/issues), [contributions](https://github.com/robfletcher/strikt/pulls), or feedback are very welcome.

## Installation

Strikt is available from Maven Central.

```kotlin
repositories {
  mavenCentral()
}

dependencies {
  testImplementation("io.strikt:strikt-core:<version>")
}
```

See the button below or [releases/latest](https://github.com/robfletcher/strikt/releases/latest) for the current version number.

## Additional Libraries

Strikt has the following additional libraries:

* `strikt-arrow` -- supports data types from the [Arrow](https://arrow-kt.io/) functional programming library.
* `strikt-jackson` -- supports the Jackson JSON library.
* `strikt-jvm` -- supports types from the Java SDK.
* `strikt-mockk` -- supports types from the [MockK](https://mockk.io/) library.
* `strikt-protobuf` -- supports Protobuf / gRPC.
* `strikt-spring` -- supports the Spring Framework.

Versions are synchronized with the core Strikt library.

To install additional libraries include dependencies in your Gradle build.
For example:

```kotlin
dependencies {
  testImplementation("io.strikt:strikt-jvm:<version>")
}
```

## Bill of Materials

Strikt supplies a BOM that is useful for aligning versions when using more than one Strikt module.

```kotlin
dependencies {
  // BOM dependency
  testImplementation(platform("io.strikt:strikt-bom:<version>"))

  // Versions can be omitted as they are supplied by the BOM
  testImplementation("io.strikt:strikt-jackson")
  testImplementation("io.strikt:strikt-jvm")
  testImplementation("io.strikt:strikt-spring")
}
```

## Using Strikt

Please see the [project documentation](https://strikt.io/) and [API docs](https://strikt.io/modules/core/).

## Community

Join the [**#strikt**](https://kotlinlang.slack.com/messages/CAR7KJ96J) channel on the Kotlin Slack.

Follow [**@stri_kt**](https://twitter.com/stri_kt) on Twitter for updates and release notifications.

![Maven Central](https://img.shields.io/maven-central/v/io.strikt/strikt-bom?style=for-the-badge)
[![GitHub Release Date](https://img.shields.io/github/release-date/robfletcher/strikt.svg?style=for-the-badge)](https://github.com/robfletcher/strikt/)
[![license](https://img.shields.io/github/license/robfletcher/strikt.svg?style=for-the-badge&logo=Apache)](https://www.apache.org/licenses/LICENSE-2.0.html)
[![GitHub issues](https://img.shields.io/github/issues/robfletcher/strikt.svg?style=for-the-badge&logo=Github)](https://github.com/robfletcher/strikt/issues)
![GitHub Workflow Status (branch)](https://img.shields.io/github/workflow/status/robfletcher/strikt/CI/master?style=for-the-badge)
![GitHub top language](https://img.shields.io/github/languages/top/robfletcher/strikt.svg?style=for-the-badge&logo=Kotlin&logoColor=white)
[![Twitter Follow](https://img.shields.io/twitter/follow/stri_kt.svg?style=for-the-badge&label=Twitter&logo=Twitter&logoColor=white)](https://twitter.com/stri_kt)


# Infrastructure of avito-android project

## Disclaimer

Right now this project is just a way for us to work as open as possible,\
and share ideas and its implementation with community.

If you plan to use some parts of our code, please let us know, \
because we don't have any public API stability guarantees atm.

However, all code you see in `develop` is running right now in Avito,\
and we rely on it to test and ship our apps.

## Project documentation

[https://avito-tech.github.io/avito-android](https://avito-tech.github.io/avito-android)

## Communication

[Telegram chat (Russian)](https://t.me/avito_android_opensource)

[Telegram chat (English)](https://t.me/avito_android_opensource_en)

## Contribution

TBD

## Why do we do open source?

- To get more feedback. We need outside perspective
- To make the code easier to change through reusing
- To share knowledge and solutions and make Android development better
- To understand better through explanation
- To supplement our presentations and articles by real production code
- To make it easier to provide reproducible samples for bugs in external libraries

## Special thanks to:

- [Dmitriy Merkuriev](https://github.com/dimorinny), [Nikolay Nesterov](https://github.com/nesterov-n), [Nikolay Chameev](https://github.com/lukaville) for being a part of the team for a long time, and creating a lot of features you see in the project.
- Remote runner projects for helping us go through dark times of pre-"Project Marble" Android Gradle plugin
  - [Mainframer](https://github.com/buildfoundation/mainframer)
  - [Mirakle](https://github.com/Instamotor-Labs/mirakle)
- Juno and [Composer test runner](https://github.com/gojuno/composer) as the basis for our own (and instrumentation output parser, still working better than ddmlib)
- [Artem Zinnatulin](https://github.com/artem-zinnatullin) for building amazing tools and being an inspiration
- [Eugene Matsyuk](https://github.com/matzuk), [Egor Kurnikov](https://github.com/eakurnikov) and [Ruslan Mingaliev](https://github.com/RuslanMingaliev) for active contribution and pushing further, building [Kaspresso](https://github.com/KasperskyLab/Kaspresso)