How to get value from StreamController? - flutter

How to get value 'data' from StreamController
stream.listen((data) {print('$data');}) ;
// global.dart
final StreamController ctrl = StreamController();
// father.dart
onSubmitted: (value) {
debugPrint('Send Data: '+areaNameTextController.text);
ctrl.sink.add('Receive Data: '+areaNameTextController.text);},
//children.dart
GoogleMap(
...
onTap: (LatLng latlng){
ctrl.stream.listen((data) {
print('$data');} ) ;
Marker(
...
infoWindow:InfoWindow(title:'///Where I want use data///'),
);
}
)

You say StreamController and In your question you wroteStream.
Should fix like that.
streamController.stream.listen(
(event) => print('Event: $event'),
onDone: () => print('Done'),
onError: (error) => print(error),
);

In my code I use like that for pull to do pull to refresh. Listening is only purpose for listening from coming data and not for action. If you want to check something that come from BLOC controller, first listening in init state and use with action from that checked data.
void initState() {
_houseVisitBloc.listAppHouseVisitStream().listen((ResponseOb res) {
if (res.message == MsgState.data) {
List<HouseVisitAppData> listenList = res.data;
mainPullList = listenList;
print(listenList.toString());
if (mainPullList == listenList) {
_refreshController.refreshCompleted();
}
if (res.data == MsgState.data) {
_refreshController.loadComplete();
}
}
if (res.data != MsgState.data) {
_refreshController.loadNoData();
}
});
super.initState();
}

In my project I use a wrapper around StreamController.
It lets me to get the very last value from StreamController.
Here is the code:
class SimpleStream<T> {
final StreamController<T> _stream = StreamController<T>();
Sink<T> get _input => _stream.sink;
Stream<T> get output => _stream.stream;
T? _currentValue;
T? get current => _currentValue;
void update(T value) {
_currentValue = value;
_input.add(value);
}
void close() {
_stream.close();
}
}

Related

navigatorState is null when using pushNamed Navigation onGenerateRoutes of GetMaterialPage

I'm using flutter_callkit_incoming package to get callsNotification in my application through the payload of FCM in all states of my App i.e background/forground/terminated state.
Navigation is fine now to the VideoCallingAgoraPage after clicking Accept button on call incoming notification on forground state of my app. -> Using listenerEvent from NikahMatch class
But problem comes when this listenerEvent is used for navigation in background/terminated state. -> Using listenerEvent as top level function because of background handler as shown below in my background handler function
When the compiler reads this line await NavigationService.instance.pushNamed(AppRoute.voiceCall); in listener event on clicking accept of notification from flutter_callKit_incoming in the background/terminated state of my app, I am getting this error in console.
E/flutter (11545): Receiver: null
E/flutter (11545): Tried calling: pushNamed<Object>("/videoCall_agora", arguments: null)
E/flutter (11545): #0 Object.noSuchMethod (dart:core-patch/object_patch.dart:38:5)
E/flutter (11545): #1 NavigationService.pushNamed (package:nikah_match/helpers/navigationService.dart:38:39)
E/flutter (11545): #2 listenerEvent.<anonymous closure> (package:nikah_match/main.dart:311:46)
E/flutter (11545): <asynchronous suspension>
E/flutter (11545):
As well as in the logs, I find that log(navigationKey.currentState.toString()); defined in pushNamed function is also null. While in the case of forground navigation, navigationKey.currentState from pushNamed function is never null.
When I received call notification in terminated state, accept case of listener event(top level function) was called without creating widget tree and initializing GetMaterialPage that caused navigator state to be null.
I think that the listnerEvent Accept case is run before starting/building widget tree and navigator key in GetMaterialPage is never assigned.
How can I get rid of that?
This is my backgroundHandler function:
Future<void> firebaseMessagingBackgroundHandler(RemoteMessage message) async {
await Firebase.initializeApp(
options: DefaultFirebaseOptions.currentPlatform,
);
bool videoCallEnabled = false;
bool audioCallEnabled = false;
if (message != null) {
debugPrint("Handling background is called");
print(
"Handling a background message and background handler: ${message.messageId}");
try {
videoCallEnabled = message.data.containsKey('videoCall');
audioCallEnabled = message.data.containsKey('voiceCall');
if (videoCallEnabled || audioCallEnabled) {
log("Video call is configured and is started");
showCallkitIncoming(Uuid().v4(), message: message);
//w8 for streaming
debugPrint("Should listen to events in background/terminated state");
listenerEvent(message);
} else {
log("No Video or audio call was initialized");
}
} catch (e) {
debugPrint("Error occured:" + e.toString());
}
}
}
This is my listener event:
Future<void> listenerEvent(RemoteMessage message) async {
log("Listner event background/terminated handler app has run");
backgroundChatRoomId = message.data['chatRoomId'];
backgroundCallsDocId = message.data['callsDocId'];
backgroundRequesterName = message.data['callerName'];
backgroundRequesterImageUrl = message.data['imageUrl'];
// String imageUrl = message.data['imageUrl'];
bool videoCallEnabled = false;
if (message.data != null) {
videoCallEnabled = message.data.containsKey('videoCall');
} else {
log("Data was null");
}
try {
FlutterCallkitIncoming.onEvent.listen((event) async {
print('HOME: $event');
switch (event.name) {
case CallEvent.ACTION_CALL_INCOMING:
// TODO: received an incoming call
log("Call is incoming");
break;
case CallEvent.ACTION_CALL_START:
// TODO: started an outgoing call
// TODO: show screen calling in Flutter
log("Call is started");
break;
case CallEvent.ACTION_CALL_ACCEPT:
// TODO: accepted an incoming call
// TODO: show screen calling in Flutter
log("......Call Accepted background/terminated state....");
currentChannel = backgroundChatRoomId;
log("currentChannel in accepted is: $currentChannel");
debugPrint("Details of call"+backgroundChatRoomId+backgroundCallsDocId );
await FirebaseFirestore.instance
.collection("ChatRoom")
.doc(backgroundChatRoomId)
.collection("calls")
.doc(backgroundCallsDocId)
.update({
'receiverCallResponse': 'Accepted',
'callResponseDateTime': FieldValue.serverTimestamp()
}).then((value) => log("Values updated at firebase firestore as Accepted"));
if (videoCallEnabled) {
log("in video call enabled in accept call of listener event");
await NavigationService.instance.pushNamed(AppRoute.videoAgoraCall,);
}
break;
}
});
} on Exception {}
}
This is my first stateful GetMaterial page which initializes all Firebase Messaging functions (Forground Local FLutter local notifications excluded from code for readability):
class NikkahMatch extends StatefulWidget {
const NikkahMatch({Key key}) : super(key: key);
#override
State<NikkahMatch> createState() => _NikkahMatchState();
}
class _NikkahMatchState extends State<NikkahMatch> with WidgetsBindingObserver {
#override
void dispose() {
WidgetsBinding.instance.removeObserver(this);
super.dispose();
}
#override
void initState() {
// TODO: implement initState
super.initState();
WidgetsBinding.instance.addObserver(this);
//Function if from terminated state
FirebaseMessaging.instance.getInitialMessage().then((message) async {
log("get Initial Message function is used.. ");
String screenName = 'No screen';
bool screenEnabled = false;
if (message != null) {
if (message.data != null) {
log("Remote message data is null for now");
if (message.data.isNotEmpty) {
screenEnabled = message.data.containsKey('screenName');
if (screenEnabled) {
if (screenName == 'chatScreen') {
log("Screen is Chat");
String type = 'Nothing';
String chatRoomId = 'Nothing';
if (message.data['type'] != null) {
type = message.data['type'];
if (type == 'profileMatched') {
String likerId = message.data['likerId'];
String likedId = message.data['likedId'];
chatRoomId = chatController.getChatRoomId(likerId, likedId);
}
} else {
chatRoomId = message.data['chatRoomId'];
}
log("ChatRoom Id is: ${chatRoomId}");
log("Navigating from onMessagePop to the ChatRoom 1");
//We have chatRoomId here and we need to navigate to the ChatRoomScreen having same Id
await FirebaseFirestore.instance
.collection("ChatRoom")
.doc(chatRoomId)
.get()
.then((value) async {
if (value.exists) {
log("ChatRoom Doc " + value.toString());
log("Navigating from onMessagePop to the ChatRoom 2");
log("Last Message was : ${value.data()['lastMessage']}");
backGroundLevelChatRoomDoc = value.data();
await NavigationService.instance.pushNamed(AppRoute.chatScreen);
} else {
log("no doc exist for chat");
}
});
}
else if (screenName == 'videoScreen') {
log("Screen is Video");
initCall(message);
} else if (screenName == 'voiceScreen') {
log("Screen is Audio");
initCall(message);
} else {
log("Screen is in Else method of getInitialMessage");
}
} else {
debugPrint("Notification Pay load data is Empty");
}
} else {
log("Screen isn't enabled");
}
} else {
log("message data is null");
}
} else {
log("...........message data is null in bahir wala else");
}
});
//This function will constantly listen to the notification recieved from firebase
FirebaseMessaging.onMessageOpenedApp.listen((RemoteMessage message) async {
log("onMessageOpenedApp function is used.. ");
String screenName = 'No screen';
bool screenEnabled = false;
if (message.data.isNotEmpty) {
screenEnabled = message.data.containsKey('screenName');
if (screenEnabled) {
//Move to the screen which is needed to
log("Screen is Enabled");
screenName = message.data['screenName'];
log("Screen name is: $screenName");
if (screenName == 'chatScreen') {
log("Screen is Chat");
String type = 'Nothing';
String chatRoomId = 'Nothing';
if (message.data['type'] != null) {
type = message.data['type'];
if (type == 'profileMatched') {
String likerId = message.data['likerId'];
String likedId = message.data['likedId'];
chatRoomId = chatController.getChatRoomId(likerId, likedId);
}
} else {
chatRoomId = message.data['chatRoomId'];
}
log("ChatRoom Id is: ${chatRoomId}");
log("Navigating from onMessagePop to the ChatRoom 1");
//We have chatRoomId here and we need to navigate to the ChatRoomScreen having same Id
await FirebaseFirestore.instance
.collection("ChatRoom")
.doc(chatRoomId)
.get()
.then((value) async {
if (value.exists) {
log("ChatRoom Doc " + value.toString());
log("Navigating from onMessagePop to the ChatRoom 2");
log("Last Message was : ${value.data()['lastMessage']}");
backGroundLevelChatRoomDoc = value.data();
/* await NavigationService.instance
.pushNamed(AppRoute.chatScreen, args:ChatArgs(value.data(), false));*/
await NavigationService.instance.pushNamed(AppRoute.chatScreen);
} else {
log("no doc exist for chat");
}
});
}
else if (screenName == 'videoScreen') {
log("Screen is Video");
initCall(message);
} else if (screenName == 'voiceScreen') {
log("Screen is Audio");
initCall(message);
} else {
log("Screen is in Else");
}
}
} else {
debugPrint("Notification Pay load data is Empty");
}
});
}
#override
Widget build(BuildContext context) {
print("Main page build");
return GetMaterialApp(
onGenerateRoute: AppRoute.generateRoute,
debugShowCheckedModeBanner: false,
navigatorKey: NavigationService.instance.navigationKey,
debugShowMaterialGrid: false,
title: 'Nikah Match',
initialRoute: '/splash_screen',
theme: ThemeData(
fontFamily: 'Poppins',
scaffoldBackgroundColor: kScaffoldBgColor,
appBarTheme: const AppBarTheme(
elevation: 0,
backgroundColor: kPrimaryColor,
),
accentColor: kPrimaryColor.withOpacity(0.2),
),
themeMode: ThemeMode.light,
getPages: [
GetPage(name: '/splash_screen', page: () => SplashScreen()),
GetPage(name: '/get_started', page: () => GetStarted()),
GetPage(
name: '/videoCall_agora',
page: () => VideoCallAgoraUIKit(
anotherUserName: backgroundRequesterName,
anotherUserImage: backgroundRequesterImageUrl,
channelName: backgroundChatRoomId,
token: "",
anotherUserId: "",
docId: backgroundCallsDocId,
callDoc: backgroundPassableAbleCdm,
),
),
// GetPage(name: '/after_log_in_screen', page: () => AfterLogin()),
],
);
}
}
This is my NavigationService class:
class NavigationService {
// Global navigation key for whole application
GlobalKey<NavigatorState> navigationKey = GlobalKey<NavigatorState>();
/// Get app context
BuildContext get appContext => navigationKey.currentContext;
/// App route observer
RouteObserver<Route<dynamic>> routeObserver = RouteObserver<Route<dynamic>>();
static final NavigationService _instance = NavigationService._private();
factory NavigationService() {
return _instance;
}
NavigationService._private();
static NavigationService get instance => _instance;
/// Pushing new page into navigation stack
///
/// `routeName` is page's route name defined in [AppRoute]
/// `args` is optional data to be sent to new page
Future<T> pushNamed<T extends Object>(String routeName,
{Object args}) async {
log(navigationKey.toString());
log(navigationKey.currentState.toString());
return navigationKey.currentState.pushNamed<T>(
routeName,
arguments: args,
);
}
Future<T> pushNamedIfNotCurrent<T extends Object>(String routeName,
{Object args}) async {
if (!isCurrent(routeName)) {
return pushNamed(routeName, args: args);
}
return null;
}
bool isCurrent(String routeName) {
bool isCurrent = false;
navigationKey.currentState.popUntil((route) {
if (route.settings.name == routeName) {
isCurrent = true;
}
return true;
});
return isCurrent;
}
/// Pushing new page into navigation stack
///
/// `route` is route generator
Future<T> push<T extends Object>(Route<T> route) async {
return navigationKey.currentState.push<T>(route);
}
/// Replace the current route of the navigator by pushing the given route and
/// then disposing the previous route once the new route has finished
/// animating in.
Future<T> pushReplacementNamed<T extends Object, TO extends Object>(
String routeName,
{Object args}) async {
return navigationKey.currentState.pushReplacementNamed<T, TO>(
routeName,
arguments: args,
);
}
/// Push the route with the given name onto the navigator, and then remove all
/// the previous routes until the `predicate` returns true.
Future<T> pushNamedAndRemoveUntil<T extends Object>(
String routeName, {
Object args,
bool Function(Route<dynamic>) predicate,
}) async {
return navigationKey.currentState.pushNamedAndRemoveUntil<T>(
routeName,
predicate==null? (_) => false: (_) => true,
arguments: args,
);
}
/// Push the given route onto the navigator, and then remove all the previous
/// routes until the `predicate` returns true.
Future<T> pushAndRemoveUntil<T extends Object>(
Route<T> route, {
bool Function(Route<dynamic>) predicate,
}) async {
return navigationKey.currentState.pushAndRemoveUntil<T>(
route,
predicate==null? (_) => false: (_) => true,
);
}
/// Consults the current route's [Route.willPop] method, and acts accordingly,
/// potentially popping the route as a result; returns whether the pop request
/// should be considered handled.
Future<bool> maybePop<T extends Object>([Object args]) async {
return navigationKey.currentState.maybePop<T>(args as T);
}
/// Whether the navigator can be popped.
bool canPop() => navigationKey.currentState.canPop();
/// Pop the top-most route off the navigator.
void goBack<T extends Object>({T result}) {
navigationKey.currentState.pop<T>(result);
}
/// Calls [pop] repeatedly until the predicate returns true.
void popUntil(String route) {
navigationKey.currentState.popUntil(ModalRoute.withName(route));
}
}
class AppRoute {
static const homePage = '/home_page';
static const chatScreen ='/chat_screen';
static const splash = '/splash_screen';
static const voiceCall = '/voice_call';
static const videoAgoraCall = '/videoCall_agora';
static Route<Object> generateRoute(RouteSettings settings) {
switch (settings.name) {
case homePage:
return MaterialPageRoute(
builder: (_) => HomePage(), settings: settings);
case chatScreen:
return MaterialPageRoute(
builder: (_) =>
ChatScreen(docs: backGroundLevelChatRoomDoc, isArchived: false,), settings: settings);
case splash:
return MaterialPageRoute(
builder: (_) => SplashScreen(), settings: settings);
case voiceCall:
return MaterialPageRoute(
builder: (_) => VoiceCall(
toCallName: backgroundRequesterName,
toCallImageUrl: backgroundRequesterImageUrl,
channelName: backgroundChatRoomId,
token: voiceCallToken,
docId: backgroundCallsDocId,
callDoc: backgroundPassableAbleCdm,
), settings: settings);
case videoAgoraCall:
return MaterialPageRoute(
builder: (_) => VideoCallAgoraUIKit(
anotherUserName: backgroundRequesterName,
anotherUserImage: backgroundRequesterImageUrl,
channelName: backgroundChatRoomId,
token: "",
anotherUserId: "",
docId: backgroundCallsDocId,
callDoc: backgroundPassableAbleCdm,
), settings: settings);
default:
return null;
}
}
}
Actually, I was also stuck when using flutter_incoming_callkit for navigation in terminated/background state for weeks, and strikingly, the solution was so simple.
The reason causing you this problem is:
-> For receiving notification in terminated or background state, backgroundHandler function is working in its own isolate and onGenerateRoutes from your NikkahMatch class is not and never known to this isolated function where you are actually trying to navigate through the pushNamed route.
So my solution was:
-> Use the combination of firestore and cloud functions for navigation. This would allow us to have the context and it won't be null as we are navigating from inside the app widget tree and not from an isolated function i.e backgroundHandler. Top-level listenerEvent Function is only used to change the values in the call document on Firestore.
[Note: Top-Level function is a function that is not part of any class]
Upon receiving flutter_incoming_callkit notification on receiver side:
On the click of Accept button, use top-level listenerEvent function to change the call status from incoming to accepted in call's document.
This will open the app from terminated/background state.
I used this function didChangeAppLifecycleState in my first class of widget tree to handle/know if app has come from terminated/background state:
Check out this code:
Future<void> didChangeAppLifecycleState(AppLifecycleState state) async {
print(state);
if (state == AppLifecycleState.resumed) {
//Check call when open app from background
print("in app life cycle resumed");
checkAndNavigationCallingPage();
}
}
checkAndNavigationCallingPage() async {
print("checkAndNavigationCallingPage CheckCalling page 1");
if (auth.currentUser != null) {
print("auth.currentUser.uid: ${auth.currentUser.uid}");
}
// NavigationService().navigationKey.currentState.pushNamed(AppRoute.videoAgoraCall);
var currentCall = await getCurrentCall();
print("inside the checkAndNavigationCallingPage and $currentCall");
if (currentCall != null) {
print("inside the currentCall != null");
//Here we have to move to calling page
final g = Get;
if (!g.isDialogOpen) {
g.defaultDialog(content: CircularProgressIndicator());
}
Future.delayed(Duration(milliseconds: 50));
await FirebaseFirestore.instance
.collection('Users')
.doc(auth.currentUser.uid)
.collection('calls')
.doc(auth.currentUser.uid)
.get()
.then((userCallDoc) async {
if (userCallDoc.exists) {
if (userCallDoc['type'] == 'chapVoiceCall' ||
userCallDoc['type'] == 'chapVideoCall') {
bool isDeclined = false;
String chapCallDocId = "";
chapCallDocId = userCallDoc['chapCallDocId'];
print(
"............. Call was Accepted by receiver or sender.............");
print("ChapCallDocId $chapCallDocId");
ChapCallDocModel cdm = ChapCallDocModel();
await FirebaseFirestore.instance
.collection("ChatRoom")
.doc(userCallDoc['chatRoomId'])
.collection("chapCalls")
.doc(chapCallDocId)
.get()
.then((value) {
if ((value['requestedResponse'] == 'Declined' &&
value['requesterResponse'] == 'Declined') ||
(value['senderResponse'] == 'Declined') ||
(value['requestedResponse'] == 'TimeOut' &&
value['requesterResponse'] == 'TimeOut')) {
isDeclined = true;
print(
"in checking declined ${value['receiverCallResponse'] == 'Declined' || value['senderCallResponse'] == 'Declined'}");
} else {
isDeclined = false;
cdm = ChapCallDocModel.fromJson(value.data());
print("CDM print is: ${cdm.toJson()}");
}
});
currentChannel = userCallDoc['chatRoomId'];
if (!isDeclined) {
if (userCallDoc['type'] == 'chapVoiceCall') {
print("in voice call enabled in accept call of listener event");
var voiceCallToken = await GetToken().getTokenMethod(
userCallDoc['chatRoomId'], auth.currentUser.uid);
print("token before if in splashscreen is: ${voiceCallToken}");
if (voiceCallToken != null) {
if (g.isDialogOpen) {
g.back();
}
Get.to(
() => ChapVoiceCall(
toCallName: userCallDoc['requesterName'],
toCallImageUrl: userCallDoc['requesterImage'],
channelName: userCallDoc['chatRoomId'],
token: voiceCallToken,
docId: userCallDoc['chapCallDocId'],
callDoc: cdm,
),
);
} else {
print(
"......Call Accepted background/terminated state....in token being null in voice call enabled in accept call of listener event");
}
} else {
if (g.isDialogOpen) {
g.back();
}
g.to(() => ChapVideoCallAgoraUIKit(
anotherUserName: userCallDoc['requesterName'],
anotherUserImage: userCallDoc['requesterImage'],
channelName: userCallDoc['chatRoomId'],
token: "",
anotherUserId: userCallDoc['requesterId'],
docId: userCallDoc['chapCallDocId'],
callDoc: cdm,
));
}
} else {
await FlutterCallkitIncoming.endAllCalls();
print(
"the call was either declined by sender or receiver or was timed out.");
}
} else {
bool isDeclined = false;
print(
"............. Call was Accepted by receiver or sender.............");
CallDocModel cdm = CallDocModel();
await FirebaseFirestore.instance
.collection("ChatRoom")
.doc(userCallDoc['chatRoomId'])
.collection("calls")
.doc(userCallDoc['callsDocId'])
.get()
.then((value) {
if (value['receiverCallResponse'] == 'Declined' ||
value['senderCallResponse'] == 'Declined' ||
value['receiverCallResponse'] == 'TimeOut' ||
value['senderCallResponse'] == 'TimeOut') {
isDeclined = true;
print(
"in checking declined ${value['receiverCallResponse'] == 'Declined' || value['senderCallResponse'] == 'Declined'}");
} else {
isDeclined = false;
cdm = CallDocModel.fromJson(value.data());
print("CDM print is: ${cdm.toJson()}");
}
});
currentChannel = userCallDoc['chatRoomId'];
if (!isDeclined) {
if (userCallDoc['type'] == 'voiceCall') {
print("in voice call enabled in accept call of listener event");
var voiceCallToken = await GetToken().getTokenMethod(
userCallDoc['chatRoomId'], auth.currentUser.uid);
print("token before if in splashscreen is: ${voiceCallToken}");
if (voiceCallToken != null) {
if (g.isDialogOpen) {
g.back();
}
Get.to(
() => VoiceCall(
toCallName: userCallDoc['requesterName'],
toCallImageUrl: userCallDoc['requesterImage'],
channelName: userCallDoc['chatRoomId'],
token: voiceCallToken,
docId: userCallDoc['callsDocId'],
callDoc: cdm,
),
);
} else {
print(
"......Call Accepted background/terminated state....in token being null in voice call enabled in accept call of listener event");
}
} else {
if (g.isDialogOpen) {
g.back();
}
g.to(() => VideoCallAgoraUIKit(
anotherUserName: userCallDoc['requesterName'],
anotherUserImage: userCallDoc['requesterImage'],
channelName: userCallDoc['chatRoomId'],
token: "",
anotherUserId: userCallDoc['requesterId'],
docId: userCallDoc['callsDocId'],
callDoc: cdm,
));
}
} else {
await FlutterCallkitIncoming.endAllCalls();
print(
"the call was either declined by sender or receiver or was timed out.");
}
}
} else {
debugPrint("Document not found");
}
});
}
}
In the above code, I have given my db scenario, so anyone, who needs to know how to handle the different call status can deeply look into it. Or you can comment here and I would be honored to reply.

How to use any state management for my bluetooth app?

I am trying to use a connected bluetooth device on other pages, but I'm unable to do that. I tried to use the provider, but that did not work, parameter passing did not work either.
After testing, I am using the following
I made a class ReactiveProvider
class ReactiveProvider(){
Stream<ConnectionStateUpdate> get currentConnectionStream {
return flutterReactiveBle.connectToAdvertisingDevice(
id: _foundBleUARTDevices[index].id,
prescanDuration: const Duration(seconds: 1),
withServices: [_uartUuid, _uartRx, _uartTx],
);
}
}
and setup in start
void main() {
runApp(
MultiProvider(providers: [
StreamProvider<ConnectionStateUpdate>(
create: (context) => ReactiveProvider().currentConnectionStream,
initialData: const ConnectionStateUpdate(
deviceId: "",
connectionState: DeviceConnectionState.disconnected,
failure: null),
)
], child: const MainApp()),
);
}
and in StatefullWidget
final _currentConnectionStream = Provider.of<ConnectionStateUpdate>(context);
I got the errors
The instance member 'context' can't be accessed in an initializer.
Try replacing the reference to the instance member with a different expression
and
The method 'listen' isn't defined for the type 'ConnectionStateUpdate'.
Try correcting the name to the name of an existing method, or defining a method named 'listen'.
In following function
_connection = _currentConnectionStream.listen((event) {});
I want to access the following parameters on another page using any state management
final flutterReactiveBle = FlutterReactiveBle();
List<DiscoveredDevice> _foundBleUARTDevices = [];
late StreamSubscription<DiscoveredDevice> _scanStream;
late Stream<ConnectionStateUpdate> _currentConnectionStream;
late StreamSubscription<ConnectionStateUpdate> _connection;
late QualifiedCharacteristic _txCharacteristic;
//late QualifiedCharacteristic _rxCharacteristic;
late Stream<List<int>> _receivedDataStream;
These are other functions I am using
void onNewReceivedData(List<int> data) {
_numberOfMessagesReceived += 1;
_receivedData
.add("$_numberOfMessagesReceived: ${String.fromCharCodes(data)}");
if (_receivedData.length > 10) {
_receivedData.removeAt(0);
}
}
void _disconnect() async {
await _connection.cancel();
_connected = false;
}
void _stopScan() async {
await _scanStream.cancel();
_scanning = false;
}
void _startScan() async {
_foundBleUARTDevices = [];
_scanning = true;
_scanStream = flutterReactiveBle
.scanForDevices(withServices: [_uartUuid]).listen((device) {
if (_foundBleUARTDevices.every((element) => element.id != device.id)) {
_foundBleUARTDevices.add(device);
}
}, onError: (Object error) {
_logTexts = "${_logTexts}ERROR while scanning:$error \n";
}, onDone: () async {
await _scanStream.cancel();
_scanning = false;
});
}
void onConnectDevice(index) {
_currentConnectionStream = flutterReactiveBle.connectToAdvertisingDevice(
id: _foundBleUARTDevices[index].id,
prescanDuration: const Duration(seconds: 1),
withServices: [_uartUuid, _uartRx, _uartTx],
);
_logTexts = "";
_connection = _currentConnectionStream.listen((event) {
var id = event.deviceId.toString();
switch (event.connectionState) {
case DeviceConnectionState.connecting:
{
_logTexts = "${_logTexts}Connecting to $id\n";
break;
}
case DeviceConnectionState.connected:
{
_connected = true;
_logTexts = "${_logTexts}Connected to $id\n";
_numberOfMessagesReceived = 0;
_receivedData = [];
_txCharacteristic = QualifiedCharacteristic(
serviceId: _uartUuid,
characteristicId: _uartTx,
deviceId: event.deviceId);
_receivedDataStream =
flutterReactiveBle.subscribeToCharacteristic(_txCharacteristic);
_receivedDataStream.listen((data) {
onNewReceivedData(data);
}, onError: (dynamic error) {
_logTexts = "${_logTexts}Error:$error$id\n";
});
break;
}
case DeviceConnectionState.disconnecting:
{
_connected = false;
_logTexts = "${_logTexts}Disconnecting from $id\n";
break;
}
case DeviceConnectionState.disconnected:
{
_logTexts = "${_logTexts}Disconnected from $id\n";
break;
}
}
});
}
Another question I have, is how I can use or keep connected using on void onConnectDevice(index) function, because as per the provider you don't need to pass the parameters.

Is there a way to access data coming from BLE device from single file which keeps updating?

I want to access characteristic values of BLE from one dart file, What I am doing is that I am connecting the device from one activity and then sending the device info to all other activities. But to get values I have to write the same code again and again to all activities/dart files.
For example i am connecting device in an activity like this:
StreamBuilder<List<ScanResult>>(
stream: FlutterBlue.instance.scanResults,
initialData: [],
builder: (c, snapshot) => Column(
children: snapshot.data
.map(
(r) => ScanResultTile(
result: r,
onTap: () => Navigator.of(context)
.push(MaterialPageRoute(builder: (context) {
r.device.connect();
print('DEVICE CONNECTED');
return BluetoothConnectedSuccess(device: r.device);
Here device: r.device is the device that i have connected to my Flutter App. Now if i want to display device data i have to initilaze these lines of code everytime i jump to any screen/activity:
class BluetoothConnectedSuccess extends StatefulWidget {
const BluetoothConnectedSuccess({Key key, this.device}) : super(key: key);
final BluetoothDevice device;
#override
_BluetoothConnectedSuccessState createState() =>
_BluetoothConnectedSuccessState();
}
class _BluetoothConnectedSuccessState extends State<BluetoothConnectedSuccess> {
// BLE
final String SERVICE_UUID = "4fafc201-1fb5-459e-8fcc-c5c9c331914b";
final String CHARACTERISTIC_UUID = "beb5483e-36e1-4688-b7f5-ea07361b26a8";
bool isReady;
Stream<List<int>> stream;
List<int> lastValue;
List<double> traceDust = List();
#override
void initState() {
super.initState();
isReady = false;
connectToDevice();
}
connectToDevice() async {
await widget.device.connect();
discoverServices();
}
discoverServices() async {
List<BluetoothService> services = await widget.device.discoverServices();
services.forEach((service) {
if (service.uuid.toString() == SERVICE_UUID) {
service.characteristics.forEach((characteristic) {
if (characteristic.uuid.toString() == CHARACTERISTIC_UUID) {
characteristic.setNotifyValue(!characteristic.isNotifying);
stream = characteristic.value;
print(stream);
lastValue = characteristic.lastValue;
print(lastValue);
setState(() {
isReady = true;
});
}
});
}
});
}
_dataParser(List<int> data) {
var value = Uint8List.fromList(data);
print("stream.value: $value"); // stream.value: [33]
var hr = ByteData.sublistView(value, 0, 1);
print("Heart rate: ${hr.getUint8(0)}");
return hr.getUint8(0); // Heart rate: 33
}
It's creating a lot of mess to write the same code again and again to the activities where BLE data is needed.
Is there a way to only call this connected device from a single file instead of initializing the same code in every activity?
This is the link to my repo for a look at what I am doing on every activity/screen with BLE device data.
Please help me out as I am new to Flutter. Thank you
Firstly learn basic of state management using Get you can refer to my code here what happens is every time something changes or upadtes it will immediate show in UI using specific Get Widgets like Obx and GetX , these widgets listen to changes in value which are marked with obs (observable).
for exmaple :
Obx(
() => ble.isScan.value ? LinearProgressIndicator() : SizedBox(),
),
this will observe the changes in isScan value .
class BleServices extends GetxController {
FlutterBlue blue = FlutterBlue.instance;
BluetoothDevice d;
var connectedDevices = List<BluetoothDevice>().obs;
var scanResults = List<ScanResult>().obs;
var bleState = BluetoothState.off.obs;
var isScan = false.obs;
var scanRequire = false.obs;
var bluetoothServices = List<BluetoothService>().obs;
var discoveringServices = false.obs;
var characteristics = List<BluetoothCharacteristic>().obs;
#override
void onInit() async {
super.onInit();
final perb = await Permission.bluetooth.status.isGranted;
final perL = await Permission.location.status.isGranted;
if (perb && perL) {
getConnectedDevices();
} else {
await Permission.bluetooth.request();
await Permission.location.request();
}
isScanning();
state();
}
isDiscovering() async {}
getConnectedDevices() async {
final connectedDevice = await blue.connectedDevices;
connectedDevices.value = connectedDevice;
AppLogger.print('connected devices : $connectedDevice');
if (connectedDevice.length == 0) {
scanRequire.value = true;
searchDevices();
}
return connectedDevice;
}
searchDevices() {
// AppLogger.print('pppppppppppppp');
blue
.scan(timeout: Duration(seconds: 20))
.distinct()
.asBroadcastStream()
.listen((event) {
AppLogger.print(event.toString());
scanResults.addIf(!scanResults.contains(event), event);
});
Future.delayed(Duration(seconds: 20), () {
blue.stopScan();
Get.showSnackbar(GetBar(
message: 'scan is finished',
));
});
}
isScanning() {
blue.isScanning.listen((event) {
AppLogger.print(event.toString());
isScan.value = event;
});
}
state() {
blue.state.listen((event) {
AppLogger.print(event.toString());
bleState.value = event;
});
}
}

flutter firestore stream mapping to another stream

I have a menus collection on firestore and I want to perform a map operation on each document and return a new stream. So, instead of the Stream<QuerySnapShop>, I wanted Stream<VendorMenuItem>
Stream<VendorMenuItem> getAllVendorMenuItems(String vendorId) async* {
var collectionReference = fs.collection('restaurants').doc('$vendorId').collection("menus").snapshots();
collectionReference.map((event) {
print("mapping");
event.docs.forEach((element) {
return VendorMenuItem.fromMap(element.data());
});
});
}
and I am calling it within a build method just to test my approach, and I got nothing printed on the console, here is how I called it
#override
Widget build(BuildContext context) {
var fs = Provider.of<FireStoreDatabaseRoute>(context);
fs.getAllVendorMenuItems("ewP3B6XWNyqjM98GYYaq").listen((event) {
print("printing final result");
print(event.name);
});
Any clues? thank you
UPDATE:
I wasn't yielding anything, however the yield keyword didnt help
Stream<VendorMenuItem> getAllVendorMenuItems(String vendorId) async* {
var collectionReference = FirebaseFirestore.instance.collection('restaurants').doc('$vendorId').collection("menus").snapshots();
yield* collectionReference.map((event) => event.docs.map((e) => VendorMenuItem.fromMap(e.data())));
}
This is how you transform stream using the method you use.
Stream<List<VendorMenuItem>> getAllVendorMenuItems(String vendorId) async* {
var collectionReference =
FirebaseFirestore.instance.collection('Files').snapshots();
yield* collectionReference.map(
(event) => event.docs
.map(
(e) => VendorMenuItem.fromMap(e.data()),
)
.toList(), //Added to list to Match the type, other wise dart will throw an error something Like MappedList is not a sub type of List
);
}
This is a second way to achieve the same task using a stream controller.
Stream<List<VendorMenuItem>> getAllVendorMenuItems2(String vendorId) {
StreamController<List<VendorMenuItem>> controller =
StreamController<List<VendorMenuItem>>();
FirebaseFirestore.instance.collection("Files").snapshots().listen((event) {
controller.add(event.docs
.map(
(e) => VendorMenuItem.fromMap(e.data()),
)
.toList() //ToList To Match type with List
);
});
return controller.stream;
}
So the reason why it didn't work was I didnt realize the map function is only a middleware and therefore the async* is not required; here is an alternative to #Taha's solution
(without the use of a stream controller)
Stream<List<VendorMenuItem>> getAllVendorMenuItems(String vendorId) {
var snapshot = fs.collection('restaurants').doc(vendorId).collection('menus').snapshots();
return snapshot.map<List<VendorMenuItem>>((event) {
return event.docs.map((e) {
return VendorMenuItem.fromMap(e.data());
}).toList();
});
}

is there any way to cancel a dart Future?

In a Dart UI, I have a button submit to launch a long async request. The submit handler returns a Future. Next, the button submit is replaced by a button cancel to allow the cancellation of the whole operation. In the cancel handler, I would like to cancel the long operation. How can I cancel the Future returned by the submit handler? I found no method to do that.
You can use CancelableOperation or CancelableCompleter to cancel a future. See below the 2 versions:
Solution 1: CancelableOperation (included in a test so you can try it yourself):
cancel a future
test("CancelableOperation with future", () async {
var cancellableOperation = CancelableOperation.fromFuture(
Future.value('future result'),
onCancel: () => {debugPrint('onCancel')},
);
// cancellableOperation.cancel(); // uncomment this to test cancellation
cancellableOperation.value.then((value) => {
debugPrint('then: $value'),
});
cancellableOperation.value.whenComplete(() => {
debugPrint('onDone'),
});
});
cancel a stream
test("CancelableOperation with stream", () async {
var cancellableOperation = CancelableOperation.fromFuture(
Future.value('future result'),
onCancel: () => {debugPrint('onCancel')},
);
// cancellableOperation.cancel(); // uncomment this to test cancellation
cancellableOperation.asStream().listen(
(value) => { debugPrint('value: $value') },
onDone: () => { debugPrint('onDone') },
);
});
Both above tests will output:
then: future result
onDone
Now if we uncomment the cancellableOperation.cancel(); then both above tests will output:
onCancel
Solution 2: CancelableCompleter (if you need more control)
test("CancelableCompleter is cancelled", () async {
CancelableCompleter completer = CancelableCompleter(onCancel: () {
print('onCancel');
});
// completer.operation.cancel(); // uncomment this to test cancellation
completer.complete(Future.value('future result'));
print('isCanceled: ${completer.isCanceled}');
print('isCompleted: ${completer.isCompleted}');
completer.operation.value.then((value) => {
print('then: $value'),
});
completer.operation.value.whenComplete(() => {
print('onDone'),
});
});
Output:
isCanceled: false
isCompleted: true
then: future result
onDone
Now if we uncomment the cancellableOperation.cancel(); we get output:
onCancel
isCanceled: true
isCompleted: true
Be aware that if you use await cancellableOperation.value or await completer.operation then the future will never return a result and it will await indefinitely if the operation was cancelled. This is because await cancellableOperation.value is the same as writing cancellableOperation.value.then(...) but then() will never be called if the operation was cancelled.
Remember to add async Dart package.
Code gist
How to cancel Future.delayed
A simple way is to use Timer instead :)
Timer _timer;
void _schedule() {
_timer = Timer(Duration(seconds: 2), () {
print('Do something after delay');
});
}
#override
void dispose() {
_timer?.cancel();
super.dispose();
}
As far as I know, there isn't a way to cancel a Future. But there is a way to cancel a Stream subscription, and maybe that can help you.
Calling onSubmit on a button returns a StreamSubscription object. You can explicitly store that object and then call cancel() on it to cancel the stream subscription:
StreamSubscription subscription = someDOMElement.onSubmit.listen((data) {
// you code here
if (someCondition == true) {
subscription.cancel();
}
});
Later, as a response to some user action, perhaps, you can cancel the subscription:
For those, who are trying to achieve this in Flutter, here is the simple example for the same.
class MyPage extends StatelessWidget {
final CancelableCompleter<bool> _completer = CancelableCompleter(onCancel: () => false);
#override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(title: Text("Future")),
body: Column(
children: <Widget>[
RaisedButton(
child: Text("Submit"),
onPressed: () async {
// it is true only if the future got completed
bool _isFutureCompleted = await _submit();
},
),
RaisedButton(child: Text("Cancel"), onPressed: _cancel),
],
),
);
}
Future<bool> _submit() async {
_completer.complete(Future.value(_solve()));
return _completer.operation.value;
}
// This is just a simple method that will finish the future in 5 seconds
Future<bool> _solve() async {
return await Future.delayed(Duration(seconds: 5), () => true);
}
void _cancel() async {
var value = await _completer.operation.cancel();
// if we stopped the future, we get false
assert(value == false);
}
}
One way I accomplished to 'cancel' a scheduled execution was using a Timer. In this case I was actually postponing it. :)
Timer _runJustOnceAtTheEnd;
void runMultipleTimes() {
_runJustOnceAtTheEnd?.cancel();
_runJustOnceAtTheEnd = null;
// do your processing
_runJustOnceAtTheEnd = Timer(Duration(seconds: 1), onceAtTheEndOfTheBatch);
}
void onceAtTheEndOfTheBatch() {
print("just once at the end of a batch!");
}
runMultipleTimes();
runMultipleTimes();
runMultipleTimes();
runMultipleTimes();
// will print 'just once at the end of a batch' one second after last execution
The runMultipleTimes() method will be called multiple times in sequence, but only after 1 second of a batch the onceAtTheEndOfTheBatch will be executed.
my 2 cents worth...
class CancelableFuture {
bool cancelled = false;
CancelableFuture(Duration duration, void Function() callback) {
Future<void>.delayed(duration, () {
if (!cancelled) {
callback();
}
});
}
void cancel() {
cancelled = true;
}
}
There is a CancelableOperation in the async package on pub.dev that you can use to do this now. This package is not to be confused with the built in dart core library dart:async, which doesn't have this class.
Change the future's task from 'do something' to 'do something unless it has been cancelled'. An obvious way to implement this would be to set a boolean flag and check it in the future's closure before embarking on processing, and perhaps at several points during the processing.
Also, this seems to be a bit of a hack, but setting the future's timeout to zero would appear to effectively cancel the future.
The following code helps to design the future function that timeouts and can be canceled manually.
import 'dart:async';
class API {
Completer<bool> _completer;
Timer _timer;
// This function returns 'true' only if timeout >= 5 and
// when cancelOperation() function is not called after this function call.
//
// Returns false otherwise
Future<bool> apiFunctionWithTimeout() async {
_completer = Completer<bool>();
// timeout > time taken to complete _timeConsumingOperation() (5 seconds)
const timeout = 6;
// timeout < time taken to complete _timeConsumingOperation() (5 seconds)
// const timeout = 4;
_timeConsumingOperation().then((response) {
if (_completer.isCompleted == false) {
_timer?.cancel();
_completer.complete(response);
}
});
_timer = Timer(Duration(seconds: timeout), () {
if (_completer.isCompleted == false) {
_completer.complete(false);
}
});
return _completer.future;
}
void cancelOperation() {
_timer?.cancel();
if (_completer.isCompleted == false) {
_completer.complete(false);
}
}
// this can be an HTTP call.
Future<bool> _timeConsumingOperation() async {
return await Future.delayed(Duration(seconds: 5), () => true);
}
}
void main() async {
API api = API();
api.apiFunctionWithTimeout().then((response) {
// prints 'true' if the function is not timed out or canceled, otherwise it prints false
print(response);
});
// manual cancellation. Uncomment the below line to cancel the operation.
//api.cancelOperation();
}
The return type can be changed from bool to your own data type. Completer object also should be changed accordingly.
A little class to unregister callbacks from future. This class will not prevent from execution, but can help when you need to switch to another future with the same type. Unfortunately I didn't test it, but:
class CancelableFuture<T> {
Function(Object) onErrorCallback;
Function(T) onSuccessCallback;
bool _wasCancelled = false;
CancelableFuture(Future<T> future,
{this.onSuccessCallback, this.onErrorCallback}) {
assert(onSuccessCallback != null || onErrorCallback != null);
future.then((value) {
if (!_wasCancelled && onSuccessCallback != null) {
onSuccessCallback(value);
}
}, onError: (e) {
if (!_wasCancelled && onErrorCallback != null) {
onErrorCallback(e);
}
});
}
cancel() {
_wasCancelled = true;
}
}
And here is example of usage. P.S. I use provider in my project:
_fetchPlannedLists() async {
if (_plannedListsResponse?.status != Status.LOADING) {
_plannedListsResponse = ApiResponse.loading();
notifyListeners();
}
_plannedListCancellable?.cancel();
_plannedListCancellable = CancelableFuture<List<PlannedList>>(
_plannedListRepository.fetchPlannedLists(),
onSuccessCallback: (plannedLists) {
_plannedListsResponse = ApiResponse.completed(plannedLists);
notifyListeners();
}, onErrorCallback: (e) {
print('Planned list provider error: $e');
_plannedListsResponse = ApiResponse.error(e);
notifyListeners();
});
}
You could use it in situations, when language changed, and request was made, you don't care about previous response and making another request!
In addition, I really was wondered that this feature didn't come from the box.
Here's a solution to cancel an awaitable delayed future
This solution is like an awaitable Timer or a cancelable Future.delayed: it's cancelable like a Timer AND awaitable like a Future.
It's base on a very simple class, CancelableCompleter, here's a demo:
import 'dart:async';
void main() async {
print('start');
// Create a completer that completes after 2 seconds…
final completer = CancelableCompleter.auto(Duration(seconds: 2));
// … but schedule the cancelation after 1 second
Future.delayed(Duration(seconds: 1), completer.cancel);
// We want to await the result
final result = await completer.future;
print(result ? 'completed' : 'canceled');
print('done');
// OUTPUT:
// start
// canceled
// done
}
Now the code of the class:
class CancelableCompleter {
CancelableCompleter.auto(Duration delay) : _completer = Completer() {
_timer = Timer(delay, _complete);
}
final Completer<bool> _completer;
late final Timer? _timer;
bool _isCompleted = false;
bool _isCanceled = false;
Future<bool> get future => _completer.future;
void cancel() {
if (!_isCompleted && !_isCanceled) {
_timer?.cancel();
_isCanceled = true;
_completer.complete(false);
}
}
void _complete() {
if (!_isCompleted && !_isCanceled) {
_isCompleted = true;
_completer.complete(true);
}
}
}
A running example with a more complete class is available in this DartPad.
You can use timeout() method
Create a dummy future:
Future<String?> _myFuture() async {
await Future.delayed(const Duration(seconds: 10));
return 'Future completed';
}
Setting a timeout of 3 seconds to stop early from 10sec:
_myFuture().timeout(
const Duration(seconds: 3),
onTimeout: () =>
'The process took too much time to finish. Please try again later',
);
and thats it you cancel your FUTURE.
there is no way unfortunately, take a look:
import 'dart:async';
import 'package:async/async.dart';
void main(List<String> args) async {
final object = SomeTimer();
await Future.delayed(Duration(seconds: 1));
object.dispose();
print('finish program');
}
class SomeTimer {
SomeTimer() {
init();
}
Future<void> init() async {
completer
.complete(Future.delayed(Duration(seconds: 10), () => someState = 1));
print('before wait');
await completer.operation.valueOrCancellation();
print('after wait');
if (completer.isCanceled) {
print('isCanceled');
return;
}
print('timer');
timer = Timer(Duration(seconds: 5), (() => print('finish timer')));
}
Timer? timer;
int _someState = 0;
set someState(int value) {
print('someState set to $value');
_someState = value;
}
CancelableCompleter completer = CancelableCompleter(onCancel: () {
print('onCancel');
});
void dispose() {
completer.operation.cancel();
timer?.cancel();
}
}
after ten seconds you will see someState set to 1 no matter what