/**@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(  ) {},


};