Android Snippets

To prevent memory leaks and unnecessary resource usage, you must cancel work launched during the object's lifecycle using the appropriate RememberObserver callbacks:

1. onForgotten(): Use this to cancel work launched from onRemembered(). This is called when the object is removed from the composition.
2. onAbandoned(): Use this to cancel any work that was launched during the object's construction (the init block) if the object was never successfully remembered by the composition.

If you are implementing a RetainObserver, use onRetired to cancel work launched from onRetained.

class MyComposeObject : RememberObserver {
    private val job = Job()
    private val coroutineScope = CoroutineScope(Dispatchers.Main + job)

    override fun onForgotten() {
        // Cancel work launched from onRemembered
        job.cancel()
    }

    override fun onAbandoned() {
        // Cancel work launched by the constructor if the object wasn't successfully remembered
        job.cancel()
    }
}

To optimize your UI for desktop environments (e.g., switching between touch-optimized and pointer-optimized layouts), use WindowInfoTracker.getOrCreate(activity) to collect windowEngagementInfo. You can check for specific engagement modes, such as WindowEngagementInfo.EngagementMode.PRECISE_POINTER, to determine if the user is interacting via a precise pointing device like a mouse.

val windowInfoTracker = WindowInfoTracker.getOrCreate(this@DesktopWindowingActivity)

lifecycleScope.launch(Dispatchers.Main) {
    lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) {
        windowInfoTracker.windowEngagementInfo(this@DesktopWindowingActivity)
            .collect { windowEngagementInfo ->
                if(windowEngagementInfo.hasEngagementMode(WindowEngagementInfo.EngagementMode.PRECISE_POINTER)){
                    showDesktopOptimizedUI()
                } else {
                    showTouchOptimizedUI()
                }
            }
    }
}

You can integrate Compose into Fragments using several methods:

1. Via XML: Use a ComposeView inside your fragment's XML layout. It is highly recommended to set a ViewCompositionStrategy (e.g., DisposeOnViewTreeLifecycleDestroyed) to ensure the composition is disposed of correctly when the view's lifecycle is destroyed.
2. Via View Binding: Access the ComposeView through your binding object.
3. Without XML: Programmatically create a ComposeView and return it from onCreateView.

// Example: Using ComposeView in a Fragment with XML
class ExampleFragmentXml : Fragment() {
    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        val view = inflater.inflate(R.layout.fragment_example, container, false)
        val composeView = view.findViewById<ComposeView>(R.id.compose_view)
        composeView.apply {
            setViewCompositionStrategy(ViewCompositionStrategy.DisposeOnViewTreeLifecycleDestroyed)
            setContent {
                MaterialTheme {
                    Text("Hello Compose!")
                }
            }
        }
        return view
    }
}

// Example: Using ComposeView without XML
class ExampleFragmentNoXml : Fragment() {
    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        return ComposeView(requireContext()).apply {
            setViewCompositionStrategy(ViewCompositionStrategy.DisposeOnViewTreeLifecycleDestroyed)
            setContent {
                MaterialTheme {
                    Text("Hello Compose!")
                }
            }
        }
    }
}

An AppFunctionService is the entry point for exposing functions to an AI agent. To implement one:

1. Extend AppFunctionService.
2. Annotate the class with @AppFunctionServiceEntryPoint, providing a serviceName and the appFunctionXmlFileName.
3. Use @AppFunction(isDescribedByKDoc = true) on suspend functions to expose them. The agent uses the KDoc to understand how to call the function.
4. Use standard exceptions like AppFunctionInvalidArgumentException or AppFunctionElementNotFoundException to communicate failures to the agent.

Note: This requires @RequiresApi(36).

@RequiresApi(36)
@AppFunctionServiceEntryPoint(
    serviceName = "TaskAppFunctionService",
    appFunctionXmlFileName = "task_app_function_service",
)
abstract class BaseTaskAppFunctionService : AppFunctionService() {
    @AppFunction(isDescribedByKDoc = true)
    suspend fun createTask(
        createTaskParams: CreateTaskParams,
    ): Task {
        if (createTaskParams.title == null && createTaskParams.content == null) {
            throw AppFunctionInvalidArgumentException("Title or content should be non-null")
        }
        // ... implementation
    }
}