Struct Instrumentation

pub struct Instrumentation {
    pub functional_test: Option<VarOrBool>,
    pub handle_profiling: Option<VarOrBool>,
    pub icon: Option<MipmapOrDrawableResource>,
    pub label: Option<StringResourceOrString>,
    pub name: String,
    pub target_package: Option<String>,
    pub target_processes: Option<String>,
}

Declares an Instrumentation class that enables you to monitor an application’s interaction with the system.

The Instrumentation object is instantiated before any of the application’s components.

XML Syntax

<instrumentation android:functionalTest=["true" | "false"]
                 android:handleProfiling=["true" | "false"]
                 android:icon="drawable resource"
                 android:label="string resource"
                 android:name="string"
                 android:targetPackage="string"
                 android:targetProcesses="string" />

Contained in:

• <manifest>

Introduced in

API Level 1

Fields

functional_test: Option<VarOrBool>

Whether or not the Instrumentation class should run as a functional test — "true" if it should, and "false" if not. The default value is "false".

handle_profiling: Option<VarOrBool>

Whether or not the Instrumentation object will turn profiling on and off — "true" if it determines when profiling starts and stops, and "false" if profiling continues the entire time it is running. A value of "true" enables the object to target profiling at a specific set of operations. The default value is "false".

icon: Option<MipmapOrDrawableResource>

An icon that represents the Instrumentation class. This attribute must be set as a reference to a drawable resource.

label: Option<StringResourceOrString>

A user-readable label for the Instrumentation class. The label can be set as a raw string or a reference to a string resource.

name: String

The name of the Instrumentation subclass. This should be a fully qualified class name (such as, "com.example.project.StringInstrumentation"). However, as a shorthand, if the first character of the name is a period, it is appended to the package name specified in the <manifest> element. There is no default. The name must be specified.

target_package: Option<String>

The application that the Instrumentation object will run against. An application is identified by the package name assigned in its manifest file by the <manifest> element.

target_processes: Option<String>

The processes that the Instrumentation object will run against. A comma-separated list indicates that the instrumentation will run against those specific processes. A value of "*" indicates that the instrumentation will run against all processes of the app defined in android:targetPackage. If this value isn’t provided in the manifest, the instrumentation will run only against the main process of the app defined in android:targetPackage.

Trait Implementations

impl Clone for Instrumentation

fn clone(&self) -> Instrumentation

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Instrumentation

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Instrumentation

fn default() -> Instrumentation

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Instrumentation

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Instrumentation

fn eq(&self, other: &Instrumentation) -> bool

Tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Instrumentation

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl YaDeserialize for Instrumentation

fn deserialize<R: Read>(reader: &mut Deserializer<R>) -> Result<Self, String>

impl YaSerialize for Instrumentation

fn serialize<W: Write>(&self, writer: &mut Serializer<W>) -> Result<(), String>

fn serialize_attributes( &self, source_attributes: Vec<OwnedAttribute>, source_namespace: Namespace, ) -> Result<(Vec<OwnedAttribute>, Namespace), String>

impl Eq for Instrumentation

impl StructuralPartialEq for Instrumentation