;
};
export const Link = ({href, label, newTab = false}) => {
const [isHovered, setIsHovered] = useState(false);
return setIsHovered(true)} onMouseLeave={() => setIsHovered(false)}>
{label}
;
};
Para provides a comprehensive set of methods for managing authentication sessions in Flutter applications. These sessions are crucial for secure transaction signing and other authenticated operations.
## Session Duration
Para session length is configured per API key and can be set up to 30 days through the Configuration section of the or CLI. The Para API enforces the configured duration. Signing a message or transaction, or calling the session keep-alive method, can extend an active session according to that configuration.
## Managing Sessions
### Checking Session Status
Use `isSessionActive()` to verify whether a user's session is currently valid before performing authenticated operations.
```dart theme={null}
Future isSessionActive()
```
In Flutter applications, it's especially important to check the session status before allowing users to access authenticated areas of your app due to the persistence of local storage between app launches.
Example usage:
```dart theme={null}
import 'package:para/para.dart';
Future checkSession() async {
try {
final isActive = await para.isSessionActive().future;
if (!isActive) {
// First clear any existing data
await para.logout().future;
// Navigate to login screen
// Handle navigation according to your app's navigation strategy
} else {
// Session is valid, proceed with app flow
// Navigate to authenticated part of your app
}
} catch (e) {
// Handle error
}
}
```
### Refreshing Expired Sessions
When a session has expired, Para recommends initiating a full authentication flow rather than trying to refresh the session.
For Flutter applications, always call `logout()` before reinitiating authentication when a session has expired to ensure all stored data is properly cleared.
```dart theme={null}
import 'package:para/para.dart';
Future handleSessionExpiration() async {
// When session expires, first clear storage
await para.logout().future;
// Then redirect to authentication screen
// Handle navigation according to your app's navigation strategy
}
```
## Exporting Sessions to Your Server
Use `exportSession()` when you need to transfer session state to your server for performing operations on behalf of the user.
```dart theme={null}
String exportSession()
```
Example implementation:
```dart theme={null}
import 'dart:convert';
import 'package:http/http.dart' as http;
import 'package:para/para.dart';
Future> sendSessionToServer() async {
// Export session without signing capabilities
final sessionData = para.exportSession();
// Send to your server
try {
final response = await http.post(
Uri.parse('https://your-api.com/sessions'),
headers: {
'Content-Type': 'application/json',
},
body: jsonEncode({'session': sessionData}),
);
if (response.statusCode != 200) {
throw Exception('Failed to send session to server');
}
return jsonDecode(response.body);
} catch (e) {
// Handle error
throw e;
}
}
```
## Best Practices for Flutter
1. **Check Sessions on App Launch**: Verify session status when your app starts to determine if users need to reauthenticate.
```dart theme={null}
import 'package:flutter/material.dart';
import 'package:para/para.dart';
// In your app's entry point or state initialization
@override
void initState() {
super.initState();
checkSessionOnLaunch();
}
Future checkSessionOnLaunch() async {
final isActive = await para.isSessionActive().future;
if (isActive) {
// Navigate to authenticated part of your app
} else {
await para.logout().future; // Clear any lingering data
// Navigate to login screen
}
}
```
2. **Handle App Lifecycle Changes**: Flutter apps can be backgrounded and foregrounded, which may affect session status.
```dart theme={null}
import 'package:flutter/material.dart';
import 'package:para/para.dart';
class YourWidget extends StatefulWidget {
@override
_YourWidgetState createState() => _YourWidgetState();
}
class _YourWidgetState extends State with WidgetsBindingObserver {
@override
void initState() {
super.initState();
WidgetsBinding.instance.addObserver(this);
}
@override
void dispose() {
WidgetsBinding.instance.removeObserver(this);
super.dispose();
}
@override
void didChangeAppLifecycleState(AppLifecycleState state) {
if (state == AppLifecycleState.resumed) {
// App came to foreground, check session
checkSession();
}
}
Future checkSession() async {
final isActive = await para.isSessionActive().future;
if (!isActive) {
await para.logout().future;
// Navigate to login screen
}
}
@override
Widget build(BuildContext context) {
// Your widget implementation
return Container();
}
}
```
## Next Steps
Explore more advanced features and integrations with Para in Flutter:
