1 files changed, 92 insertions, 0 deletions
diff --git a/libatrace_rust/example/src/main.rs b/libatrace_rust/example/src/main.rs
new file mode 100644
index 00000000..84e3e470
--- /dev/null
+++ b/libatrace_rust/example/src/main.rs
@@ -0,0 +1,92 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// 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.
+
+//! Usage sample for libatrace_rust.
+
+use std::thread::JoinHandle;
+
+use atrace::AtraceTag;
+
+fn spawn_async_event() -> JoinHandle<()> {
+    // Unlike normal events, async events don't need to be nested.
+    // You need to use the same name and cookie (the last arg) to close the event.
+    // The cookie must be unique on the name level.
+    let unique_cookie = 12345;
+    atrace::atrace_async_begin(AtraceTag::App, "Async task", unique_cookie);
+    std::thread::spawn(move || {
+        std::thread::sleep(std::time::Duration::from_millis(500));
+        atrace::atrace_async_end(AtraceTag::App, "Async task", unique_cookie);
+    })
+}
+
+fn spawn_async_event_with_track() -> JoinHandle<()> {
+    // Same as `atrace_async_begin` but per track.
+    // Track name (not event name) and cookie are used to close the event.
+    // The cookie must be unique on the track level.
+    let unique_cookie = 12345;
+    atrace::atrace_async_for_track_begin(
+        AtraceTag::App,
+        "Async track",
+        "Task with track",
+        unique_cookie,
+    );
+    std::thread::spawn(move || {
+        std::thread::sleep(std::time::Duration::from_millis(600));
+        atrace::atrace_async_for_track_end(AtraceTag::App, "Async track", unique_cookie);
+    })
+}
+
+fn spawn_counter_thread() -> JoinHandle<()> {
+    std::thread::spawn(|| {
+        for i in 1..=10 {
+            std::thread::sleep(std::time::Duration::from_millis(100));
+            // Counter events are available for int and int64 to trace values.
+            atrace::atrace_int(AtraceTag::App, "Count of i", i);
+        }
+    })
+}
+
+fn main() {
+    // This macro will create a scoped event with the function name used as the event name.
+    atrace::trace_method!(AtraceTag::App);
+
+    // The scoped event will be ended when the returned guard is dropped.
+    let _scoped_event = atrace::begin_scoped_event(AtraceTag::App, "Example main");
+
+    // Methods starting with atrace_* are direct wrappers of libcutils methods.
+    let enabled_tags = atrace::atrace_get_enabled_tags();
+    println!("Enabled tags: {:?}", enabled_tags);
+
+    println!("Spawning async trace events");
+    let async_event_handler = spawn_async_event();
+    let async_event_with_track_handler = spawn_async_event_with_track();
+    let counter_thread_handler = spawn_counter_thread();
+
+    // Instant events have no duration and don't need to be closed.
+    atrace::atrace_instant(AtraceTag::App, "Instant event");
+
+    println!("Calling atrace_begin and sleeping for 1 sec...");
+    // If you begin an event you need to close it with the same tag. If you're calling begin
+    // manually make sure you have a matching end. Or just use a scoped event.
+    atrace::atrace_begin(AtraceTag::App, "Hello tracing!");
+    std::thread::sleep(std::time::Duration::from_secs(1));
+    atrace::atrace_end(AtraceTag::App);
+
+    println!("Joining async events...");
+    async_event_handler.join().unwrap();
+    async_event_with_track_handler.join().unwrap();
+    counter_thread_handler.join().unwrap();
+
+    println!("Done!");
+}