Update scopes documentation for Java and Android

src/includes/enriching-events/attachment-upload/android.mdx

@@ -0,0 +1,33 @@
+```java
+import io.sentry.Sentry;
+import io.sentry.Attachment;
+
+Attachment fileAttachment = new Attachment("your/path/file.log");
+
+// Add an attachment
+Sentry.configureScope(scope -> {
+  scope.addAttachment(fileAttachment);
+});
+
+// Clear all attachments
+Sentry.configureScope(scope -> {
+  scope.clearAttachments();
+});
+```
+
+```kotlin
+import io.sentry.Sentry
+import io.sentry.Attachment
+
+val fileAttachment = Attachment("your/path/file.log")
+
+// Add an attachment
+Sentry.configureScope { scope ->
+  scope.addAttachment(fileAttachment)
+}
+
+// Clear all attachments
+Sentry.configureScope { scope ->
+  scope.clearAttachments()
+}
+```

src/includes/enriching-events/scopes/configure-scope/android.mdx

@@ -1,11 +1 @@
 <PlatformContent includePath="enriching-events/scopes/configure-scope/java.mdx" />
-
-### Scope Synchronization
-
-If you want to set context data in the Java layer, then receive that context data when a native (C/C++) crash happens, you need to synchronize the Java `Scope` with the native `Scope`. This feature was introduced in version `3.0.0` of the Android SDK and requires an opt-in:
-
-```xml {filename:AndroidManifest.xml}
-<application>
-    <meta-data android:name="io.sentry.ndk.scope-sync.enable" android:value="true" />
-</application>
-```

src/includes/enriching-events/scopes/scope-synchronization/android.mdx

@@ -0,0 +1,9 @@
+### Scope Synchronization
+
+If you want to set context data in the Java layer, then receive that context data when a native (C/C++) crash happens, you need to synchronize the Java `Scope` with the native `Scope`. This feature was introduced in version `3.0.0` of the Android SDK and requires an opt-in:
+
+```xml {filename:AndroidManifest.xml}
+<application>
+    <meta-data android:name="io.sentry.ndk.scope-sync.enable" android:value="true" />
+</application>
+```

src/includes/getting-started-install/android.mdx

@@ -28,4 +28,6 @@ Sentry's Android SDK depends on [Gson](https://github.com/google/gson) as a tran
 
 If you are using multiple Sentry dependencies, you can add a [bill of materials](/platforms/android/configuration/bill-of-materials) to avoid specifying the version of each dependency.
 
+If you are using Kotlin and coroutines in your Android project, you should read [Using Sentry SDK with Coroutines](/platforms/android/enriching-events/scopes/#kotlin-coroutines)
+
 </Note>

src/platforms/common/enriching-events/attachments/index.mdx

@@ -86,14 +86,22 @@ You'll first need to import the SDK, as usual:
 
 </PlatformSection>
 
-<PlatformSection notSupported={["unity"]} supported={["android", "apple", "java", "dotnet", "dart", "flutter"]}>
+<PlatformSection notSupported={["unity", "android"]} supported={["apple", "java", "dotnet", "dart", "flutter"]}>
 
 Attachments live on the <PlatformLink to="/enriching-events/scopes/">Scope</PlatformLink>. You can either add an attachment on the global scope to be sent with every event or add it on the <PlatformLink to="/enriching-events/scopes/#local-scopes">local Scope</PlatformLink> to just send the attachment with one specific event.
 
 <PlatformContent includePath="enriching-events/attachment-upload" />
 
 </PlatformSection>
 
+<PlatformSection supported={["android"]}>
+
+Attachments live on the <PlatformLink to="/enriching-events/scopes/">Scope</PlatformLink>, and will be sent with all events.
+
+<PlatformContent includePath="enriching-events/attachment-upload" />
+
+</PlatformSection>
+
 <PlatformSection supported={["unity"]}>
 
 Unity features a global <PlatformLink to="/enriching-events/scopes/">scope</PlatformLink> to which you add an attachment that will be sent with every event.

src/platforms/common/enriching-events/scopes.mdx

@@ -40,11 +40,11 @@ routes or controllers.
 ## How the Scope and Hub Work
 
 As you start using an SDK, a scope and hub are automatically created for you out
-of the box. You are unlikely to be interacting with the hub directly unless you
+of the box. It is unlikely that you will interact with the hub directly unless you
 are writing an integration or you want to create or destroy scopes. Scopes, on the
-other hand are more user facing. You can at any point in time call
-`configure-scope` to modify data stored on the scope. This is for instance
-used to [modify the context](../context/).
+other hand are more user facing. You may call `configure-scope` at any point in
+time to to modify data stored on the scope. This is useful for doing things like
+[modifying the context](../context/).
 
 <Alert>
 If you are very curious about how thread locality works: On platforms such as .NET
@@ -80,28 +80,44 @@ You can also apply this configuration when unsetting a user at logout:
 
 <PlatformContent includePath="enriching-events/unset-user" />
 
+<PlatformSection supported={["android"]}>
+
+<PlatformContent includePath="enriching-events/scopes/scope-synchronization" />
+
+</PlatformSection>
+
 To learn what useful information can be associated with scopes see
 [the context documentation](../context/).
 
+<PlatformSection notSupported={["android"]}>
+
 ## Local Scopes
 
-We also have support for pushing and configuring a scope in one go. This is typically called `with-scope` or `push-scope` which is also very helpful if you only want to send data with one specific event. In the following example we are using that function to attach a `level` and a `tag` to only one specific error:
+We also support pushing and configuring a scope within a single call. This is typically
+called `with-scope` or `push-scope` depending on the SDK, and is very helpful if
+you only want to send data for one specific event. In the following example we use
+`with-scope` to attach a `level` and a `tag` to only one specific error:
 
 <PlatformContent includePath="enriching-events/scopes/with-scope" />
 
-While this example looks similar to `configure-scope`, it's very different, in the sense that `configure-scope` actually changes the current active scope, all successive calls to `configure-scope`
-will keep the changes.
+While this example looks similar to `configure-scope`, it is actually very different.
+Calls to `configure-scope` change the current active scope; all successive calls
+to `configure-scope` will maintain previously set changes unless they are explicitly
+unset.
 
-While on the other hand using `with-scope` creates a clone of the current scope
-and will stay isolated until the function call is completed. So you can either
-set context information in there that you don't want to be somewhere else or not
-attach any context information at all by calling `clear` on the scope, while the
-"global" scope remains unchanged.
+`with-scope` on the other hand creates a clone of the current scope and the changes
+made will stay isolated within the `with-scope` callback function. This allows you to
+easily isolate pieces of context information to specific locations in your code or
+even call `clear` to briefly remove all context information.
 
-Keep in mind that `with-scope` will not capture any exceptions that happen inside its callback function,
-and every error that happens there will be silently ignored and *not* reported.
+<Alert level="info" title="Important">
+Any exceptions that occur within the callback function for `with-scope` will not be
+caught and all errors that occur will be silently ignored and *not* repoted.
+</Alert>
+
+</PlatformSection>
 
-<PlatformSection supported={["java"]} notSupported={["android"]}>
+<PlatformSection supported={["java", "android"]}>
 
 ## Kotlin Coroutines
 
@@ -140,4 +156,5 @@ launch(SentryContext()) {
   }
 }
 ```
+
 </PlatformSection>