CODEWITHSUNDEEP
flutterdebuggingdartflutter-runflutter-debug
Kevin Walter
Kevin Walter

Reputation: 7186

How can I check if a Flutter application is running in debug?

I'm looking for a way to execute code in Flutter when the app is in Debug mode. Is that possible in Flutter? I can't seem to find it anywhere in the documentation.

Something like this

If(app.inDebugMode) {
   print("Print only in debug mode");
}

How can I check if the Flutter application is running in debug or release mode?

Upvotes: 320

Views: 109264

Answers (13)

Fakhriddin Abdullaev
Fakhriddin Abdullaev

Reputation: 4940

In flutter you can use “foundations” package to check is the app debug or release by using the following constants:

  • kReleaseMode
  • kProfileMode
  • kDebugMode

**

Here is an example:

**

import 'package:flutter/foundation.dart';

modeFinder() {
  String currentMode;

  if (kDebugMode) {
       currentMode = "Debug mode"
  } else if (kReleaseMode) {
       currentMode = "Release mode"
  } else {
       currentMode = "Profile mode"
  }

  print(string);
}

Upvotes: 3

Vahid Rajabi
Vahid Rajabi

Reputation: 359

you can use flutter's foundation library. You can get debug, profile and release

import 'package:flutter/foundation.dart';

then

if (kDebugMode) {
  // debug code
}

if (kProfileMode) {
 // profile code
}

if (kReleaseMode) {
    // release code
}

Upvotes: 3

Cícero Moura
Cícero Moura

Reputation: 2333

I've created this useful class, based on other answers and inspired on Android usage. If anything changes on "Foundation" package, it would not be necessary to change the entire application, it would be necessary to change only this class.

import 'package:flutter/foundation.dart' as Foundation;

abstract class Build {

    static const bool isDebugMode = Foundation.kDebugMode;

    static const bool isReleaseMode = Foundation.kReleaseMode;

    static const bool isWeb = Foundation.kIsWeb;

    static const bool isProfileMode = Foundation.kProfileMode;
}

Upvotes: 3

Anandh Krishnan
Anandh Krishnan

Reputation: 6022

Just import this

import 'package:flutter/foundation.dart' 


String bulid = kReleaseMode ? "Release" : "";

or

String bulid = kDebugMode ? "Debug" : "";

or

String bulid = kProfileMode ? "Profile" : "";

Or try this

if (kDebugMode) {
   print("Debug");
} else if (kReleaseMode) {
    print("Release"); 
} else if (kProfileMode) {
  print("Profile"); 
}

Upvotes: 5

creativecreatorormaybenot
creativecreatorormaybenot

Reputation: 127024

kDebugMode

You can now use the kDebugMode constant.

if (kDebugMode) {
  // Code here will only be included in debug mode.
  // As kDebugMode is a constant, the tree shaker
  // will remove the code entirely from compiled code.
} else {

}

This is preferable over !kReleaseMode as it also checks for profile mode, i.e., kDebugMode means not in release mode and not in profile mode.

kReleaseMode

If you just want to check for release mode and not for profile mode, you can use kReleaseMode instead:

if (kReleaseMode) {
  // Code here will only be run in release mode.
  // As kReleaseMode is a constant, the tree shaker
  // will remove the code entirely from other builds.
} else {

}

kProfileMode

If you just want to check for profile mode and not for release mode, you can use kProfileMode instead:

if (kProfileMode) {
  // Code here will only be run in release mode.
  // As kProfileMode is a constant, the tree shaker
  // will remove the code entirely from other builds.
} else {

}

Upvotes: 76

Rémi Rousselet
Rémi Rousselet

Reputation: 277707

In later versions, you can use kDebugMode:

if (kDebugMode)
  doSomething();

While asserts can technically be used to manually create an "is debug mode" variable, you should avoid that.

Instead, use the constant kReleaseMode from package:flutter/foundation.dart

The difference is all about tree shaking.

Tree shaking (aka the compiler removing unused code) depends on variables being constants.

The issue is, with asserts our isInReleaseMode boolean is not a constant. So when shipping our app, both the dev and release code are included.

On the other hand, kReleaseMode is a constant. Therefore the compiler is correctly able to remove unused code, and we can safely do:

if (kReleaseMode) {

} else {
  // Will be tree-shaked on release builds.
}

Upvotes: 633

Kalpesh Kundanani
Kalpesh Kundanani

Reputation: 5763

Here is a simple solution to this:

import 'package:flutter/foundation.dart';

Then you can use kReleaseMode like

if(kReleaseMode){ // Is Release Mode??
    print('release mode');
} else {
    print('debug mode');
}

Upvotes: 111

Hadrien Lejard
Hadrien Lejard

Reputation: 5924

Please use Remi's answer with kReleaseMode and kDebugMode or Dart compilation won't be able to tree-shake your code.

This little snippet should do what you need:

bool get isInDebugMode {
  bool inDebugMode = false;
  assert(inDebugMode = true);
  return inDebugMode;
}

If not, you can configure your IDE to launch a different main.dart in debug mode where you can set a Boolean.

Upvotes: 69

rmtmckenzie
rmtmckenzie

Reputation: 40513

While this works, using constants kReleaseMode or kDebugMode is preferable. See Rémi's answer below for a full explanation, which should probably be the accepted question.

The easiest way is to use assert as it only runs in debug mode.

Here's an example from Flutter's Navigator source code:

assert(() {
  if (navigator == null && !nullOk) {
    throw new FlutterError(
      'Navigator operation requested with a context that does not include a Navigator.\n'
      'The context used to push or pop routes from the Navigator must be that of a '
      'widget that is a descendant of a Navigator widget.'
    );
  }
  return true;
}());

Note in particular the () at the end of the call - assert can only operate on a Boolean, so just passing in a function doesn't work.

Upvotes: 61

Neeraj
Neeraj

Reputation: 2557

Not to be picky, but the foundation package includes a kDebugMode constant.

So:

import 'package:flutter/foundation.dart' as Foundation;

if(Foundation.kDebugMode) {
   print("App in debug mode");
}

Upvotes: 30

Manan Domadiya
Manan Domadiya

Reputation: 157

Make a file named constants.dart. Add these variables in it:

const bool kReleaseMode = bool.fromEnvironment('dart.vm.product');
const bool kProfileMode = bool.fromEnvironment('dart.vm.profile');
const bool kDebugMode = !kReleaseMode && !kProfileMode;

printk(String string) {
  if (kDebugMode) {
    // ignore: avoid_print
    print(string);
  }
}

Then import this constant file in any other file and use it like this:

    import 'package:package_name/constants.dart';

    if(kDebugMode){
        //Debug code
    }else{
        //Non-Debug code
    }

    printk("Debug Log");

Upvotes: 2

Travis Reeder
Travis Reeder

Reputation: 41143

I believe the latest way to do this is:

const bool prod = const bool.fromEnvironment('dart.vm.product');

src

Upvotes: 11

teteArg
teteArg

Reputation: 4024

Extracted from Dart Documentation:

When exactly do assertions work? That depends on the tools and framework you’re using:

  • Flutter enables assertions in debug mode.
  • Development-only tools such as dartdevc typically enable assertions by default.
  • Some tools, such as dart and dart2js, support assertions through a command-line flag: --enable-asserts.

In production code, assertions are ignored, and the arguments to assert aren’t evaluated.

Upvotes: 0

Related Questions