Morioh
Login
Flutter Packages

Flutter Packages

10 months ago

A Flutter Plugin for Controlling Screen Brightness

A Plugin for controlling screen brightness with application life cycle reset implemented.

This plugin only changes application brightness not system brightness. So no permission is needed for this plugin.

Getting Started

Install

Add the following lines in your pubspec.yaml file

  screen_brightness: ^latest_version

API

System brightness

Future<double> get systemBrightness async {
  try {
    return await ScreenBrightness().system;
  } catch (e) {
    print(e);
    throw 'Failed to get system brightness';
  }
}

Current brightness

Future<double> get currentBrightness async {
  try {
    return await ScreenBrightness().current;
  } catch (e) {
    print(e);
    throw 'Failed to get current brightness';
  }
}

Set brightness

Future<void> setBrightness(double brightness) async {
  try {
    await ScreenBrightness().setScreenBrightness(brightness);
  } catch (e) {
    print(e);
    throw 'Failed to set brightness';
  }
}

Reset brightness

Future<void> resetBrightness() async {
  try {
    await ScreenBrightness().resetScreenBrightness();
  } catch (e) {
    print(e);
    throw 'Failed to reset brightness';
  }
}

Current brightness changed stream

@override
Widget build(BuildContext context) {
  return StreamBuilder<double>(
    stream: ScreenBrightness().onCurrentBrightnessChanged,
    builder: (context, snapshot) {
      double changedBrightness = currentBrightness;
      if (snapshot.hasData) {
        changedBrightness = snapshot.data!;
      }
        
      return Text('current brightness $changedBrightness');
    },
  );
}

Has changed

@override
Widget build(BuildContext context) {
  return FutureBuilder<bool>(
    future: ScreenBrightness().hasChanged,
    builder: (context, snapshot) {
      return Text(
          'Brightness has changed via plugin: ${snapshot.data}');
    },
  );
}

Auto reset (iOS only) (experiment feature things maybe weird)

bool isAutoReset = true;

Future<void> getAutoResetSetting() async {
  if (!Platform.isIOS) {
    return;
  }

  final _isAutoReset = await ScreenBrightness().isAutoReset;
  setState(() {
    isAutoReset = _isAutoReset;
  });
}

@override
Widget build(BuildContext context) {
  return Switch(
    value: isAutoReset,
    onChanged: !Platform.isIOS
        ? null
        : (value) async {
      await ScreenBrightness().setAutoReset(value);
      await getAutoResetSetting();
    },
  );
}

Usage

  • DON'T use didChangeAppLifecycleState to set or reset brightness because this plugin already implemented this function.
  • You may also use this plugin with wakelock to prevent screen sleep

Maintainer

Jack Liu

Use this package as a library

Depend on it

Run this command:

With Flutter:

 $ flutter pub add screen_brightness

This will add a line like this to your package's pubspec.yaml (and run an implicit flutter pub get):

dependencies:
  screen_brightness: ^0.2.2

Alternatively, your editor might support flutter pub get. Check the docs for your editor to learn more.

Import it

Now in your Dart code, you can use:

import 'package:screen_brightness/screen_brightness.dart';

example/lib/main.dart

import 'dart:io';

import 'package:flutter/material.dart';
import 'package:screen_brightness/screen_brightness.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  static final RouteObserver<Route> routeObserver = RouteObserver<Route>();

  const MyApp({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: const HomePage(),
      onGenerateRoute: (settings) {
        late final Widget page;
        switch (settings.name) {
          case HomePage.routeName:
            page = const HomePage();
            break;

          case ControllerPage.routeName:
            page = const ControllerPage();
            break;

          case RouteAwarePage.routeName:
            page = const RouteAwarePage();
            break;

          case BlankPage.routeName:
            page = const BlankPage();
            break;

          case SettingPage.routeName:
            page = const SettingPage();
            break;

          default:
            throw UnimplementedError('page name not found');
        }

        return MaterialPageRoute(
          builder: (context) => page,
          settings: settings,
        );
      },
      navigatorObservers: [
        routeObserver,
      ],
    );
  }
}

class HomePage extends StatelessWidget {
  static const routeName = '/home';

  const HomePage({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Screen brightness example'),
      ),
      body: Padding(
        padding: const EdgeInsets.all(8.0),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.stretch,
          children: [
            FutureBuilder<double>(
              future: ScreenBrightness().current,
              builder: (context, snapshot) {
                double currentBrightness = 0;
                if (snapshot.hasData) {
                  currentBrightness = snapshot.data!;
                }

                return StreamBuilder<double>(
                  stream: ScreenBrightness().onCurrentBrightnessChanged,
                  builder: (context, snapshot) {
                    double changedBrightness = currentBrightness;
                    if (snapshot.hasData) {
                      changedBrightness = snapshot.data!;
                    }

                    return Text('current brightness $changedBrightness');
                  },
                );
              },
            ),
            ElevatedButton(
              onPressed: () =>
                  Navigator.of(context).pushNamed(ControllerPage.routeName),
              child: const Text('Controller example page'),
            ),
            ElevatedButton(
              onPressed: () =>
                  Navigator.of(context).pushNamed(RouteAwarePage.routeName),
              child: const Text('Route aware example page'),
            ),
            ElevatedButton(
              onPressed: () =>
                  Navigator.of(context).pushNamed(SettingPage.routeName),
              child: const Text('Setting page'),
            ),
          ],
        ),
      ),
    );
  }
}

class ControllerPage extends StatefulWidget {
  static const routeName = '/controller';

  const ControllerPage({Key? key}) : super(key: key);

  @override
  State<ControllerPage> createState() => _ControllerPageState();
}

class _ControllerPageState extends State<ControllerPage> {
  Future<void> setBrightness(double brightness) async {
    try {
      await ScreenBrightness().setScreenBrightness(brightness);
    } catch (e) {
      debugPrint(e.toString());
      throw 'Failed to set brightness';
    }
  }

  Future<void> resetBrightness() async {
    try {
      await ScreenBrightness().resetScreenBrightness();
    } catch (e) {
      debugPrint(e.toString());
      throw 'Failed to reset brightness';
    }
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Controller'),
      ),
      body: Center(
        child: FutureBuilder<double>(
          future: ScreenBrightness().current,
          builder: (context, snapshot) {
            double currentBrightness = 0;
            if (snapshot.hasData) {
              currentBrightness = snapshot.data!;
            }

            return StreamBuilder<double>(
              stream: ScreenBrightness().onCurrentBrightnessChanged,
              builder: (context, snapshot) {
                double changedBrightness = currentBrightness;
                if (snapshot.hasData) {
                  changedBrightness = snapshot.data!;
                }

                return Column(
                  mainAxisSize: MainAxisSize.min,
                  children: [
                    FutureBuilder<bool>(
                      future: ScreenBrightness().hasChanged,
                      builder: (context, snapshot) {
                        return Text(
                            'Brightness has changed via plugin: ${snapshot.data}');
                      },
                    ),
                    Text('Current brightness: $changedBrightness'),
                    Slider.adaptive(
                      value: changedBrightness,
                      onChanged: (value) {
                        setBrightness(value);
                      },
                    ),
                    ElevatedButton(
                      onPressed: () {
                        resetBrightness();
                      },
                      child: const Text('reset brightness'),
                    ),
                  ],
                );
              },
            );
          },
        ),
      ),
    );
  }
}

class RouteAwarePage extends StatefulWidget {
  static const routeName = '/routeAware';

  const RouteAwarePage({Key? key}) : super(key: key);

  @override
  _RouteAwarePageState createState() => _RouteAwarePageState();
}

class _RouteAwarePageState extends State<RouteAwarePage> with RouteAware {
  @override
  void didChangeDependencies() {
    super.didChangeDependencies();
    MyApp.routeObserver.subscribe(this, ModalRoute.of(context)!);
  }

  @override
  void dispose() {
    MyApp.routeObserver.unsubscribe(this);
    super.dispose();
  }

  @override
  void didPush() {
    super.didPush();
    ScreenBrightness().setScreenBrightness(0.7);
  }

  @override
  void didPushNext() {
    super.didPushNext();
    ScreenBrightness().resetScreenBrightness();
  }

  @override
  void didPop() {
    super.didPop();
    ScreenBrightness().resetScreenBrightness();
  }

  @override
  void didPopNext() {
    super.didPopNext();
    ScreenBrightness().setScreenBrightness(0.7);
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Route aware'),
      ),
      body: Center(
        child: ElevatedButton(
          onPressed: () => Navigator.of(context).pushNamed(BlankPage.routeName),
          child: const Text('Next page'),
        ),
      ),
    );
  }
}

class BlankPage extends StatelessWidget {
  static const routeName = '/blankPage';

  const BlankPage({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Blank'),
      ),
    );
  }
}

class SettingPage extends StatefulWidget {
  static const routeName = '/setting';

  const SettingPage({Key? key}) : super(key: key);

  @override
  _SettingPageState createState() => _SettingPageState();
}

class _SettingPageState extends State<SettingPage> {
  bool isAutoReset = true;

  @override
  void initState() {
    super.initState();
    getAutoResetSetting();
  }

  Future<void> getAutoResetSetting() async {
    final _isAutoReset = await ScreenBrightness().isAutoReset;
    setState(() {
      isAutoReset = _isAutoReset;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Setting'),
      ),
      body: ListView(
        children: [
          ListTile(
            title: const Text('Auto Reset (iOS only)'),
            trailing: Switch(
              value: isAutoReset,
              onChanged:
                  Platform.isIOS || Platform.isWindows || Platform.isMacOS
                      ? (value) async {
                          await ScreenBrightness().setAutoReset(value);
                          await getAutoResetSetting();
                        }
                      : null,
            ),
          )
        ],
      ),
    );
  }
}

Download details:

Author: aaassseee

Source: https://github.com/aaassseee/screen_brightness/tree/master/screen_brightness

#flutter #ui #applications #mobileapp #mobile-apps #mobile #android 

A Flutter Plugin for Controlling Screen Brightness
1.25 GEEK