/**@class android.os.StrictMode.VmPolicy.Builder @extends java.lang.Object Creates {@link android.os.StrictMode.VmPolicy} instances. Methods whose names start with {@code detect} specify what problems we should look for. Methods whose names start with {@code penalty} specify what we should do when we detect a problem. <p>You can call as many {@code detect} and {@code penalty} methods as you like. Currently order is insignificant: all penalties apply to all detected problems. <p>For example, detect everything and log anything that's found: <pre> StrictMode.VmPolicy policy = new StrictMode.VmPolicy.Builder() .detectAll() .penaltyLog() .build(); StrictMode.setVmPolicy(policy); </pre> */ var Builder = { /**Set an upper bound on how many instances of a class can be in memory at once. Helps to prevent object leaks. */ setClassInstanceLimit : function( ) {}, /**Detect leaks of {@link android.app.Activity} subclasses. */ detectActivityLeaks : function( ) {}, /**Detect everything that's potentially suspect. <p>In the Honeycomb release this includes leaks of SQLite cursors, Activities, and other closable objects but will likely expand in future releases. */ detectAll : function( ) {}, /**Detect when an {@link android.database.sqlite.SQLiteCursor} or other SQLite object is finalized without having been closed. <p>You always want to explicitly close your SQLite cursors to avoid unnecessary database contention and temporary memory leaks. */ detectLeakedSqlLiteObjects : function( ) {}, /**Detect when an {@link java.io.Closeable} or other object with a explict termination method is finalized without having been closed. <p>You always want to explicitly close such objects to avoid unnecessary resources leaks. */ detectLeakedClosableObjects : function( ) {}, /**Detect when a {@link BroadcastReceiver} or {@link android.os.Pkg.ServiceConnection} is leaked during {@link Context} teardown. */ detectLeakedRegistrationObjects : function( ) {}, /**Detect when a {@code file://} {@link android.net.Uri} is exposed beyond this app. The receiving app may not have access to the sent path. Instead, when sharing files between apps, {@code content://} should be used with permission grants. */ detectFileUriExposure : function( ) {}, /**Detect any network traffic from the calling app which is not wrapped in SSL/TLS. This can help you detect places that your app is inadvertently sending cleartext data across the network. <p> Using {@link #penaltyDeath}() or {@link #penaltyDeathOnCleartextNetwork}() will block further traffic on that socket to prevent accidental data leakage, in addition to crashing your process. <p> Using {@link #penaltyDropBox}() will log the raw contents of the packet that triggered the violation. <p> This inspects both IPv4/IPv6 and TCP/UDP network traffic, but it may be subject to false positives, such as when STARTTLS protocols or HTTP proxies are used. */ detectCleartextNetwork : function( ) {}, /**Crashes the whole process on violation. This penalty runs at the end of all enabled penalties so you'll still get your logging or other violations before the process dies. */ penaltyDeath : function( ) {}, /**Crashes the whole process when cleartext network traffic is detected. @see #detectCleartextNetwork() */ penaltyDeathOnCleartextNetwork : function( ) {}, /**Log detected violations to the system log. */ penaltyLog : function( ) {}, /**Enable detected violations log a stacktrace and timing data to the {@link android.os.DropBoxManager DropBox} on policy violation. Intended mostly for platform integrators doing beta user field data collection. */ penaltyDropBox : function( ) {}, /**Construct the VmPolicy instance. <p>Note: if no penalties are enabled before calling <code>build</code>, {@link #penaltyLog} is implicitly set. */ build : function( ) {}, };