24 posts tagged with "Flutter"

class _MyHomePageState extends State<MyHomePage> with SingleTickerProviderStateMixin {
  late AnimationController _controller;

  @override
  void initState() {
    super.initState();
    _controller = AnimationController(
      duration: const Duration(seconds: 2),
      vsync: this,
    );
  }

  @override
  void dispose() {
    _controller.dispose();
    super.dispose();
  }
}

final animation = Tween<double>(
  begin: 0,
  end: 300,
).animate(_controller);

AnimatedContainer(
  duration: Duration(milliseconds: 500),
  width: _isExpanded ? 300.0 : 100.0,
  height: _isExpanded ? 300.0 : 100.0,
  color: _isExpanded ? Colors.blue : Colors.red,
  curve: Curves.fastOutSlowIn,
)

Hero(
  tag: 'imageHero',
  child: Image.network('url_to_image'),
)

class StaggeredAnimation extends StatelessWidget {
  final Animation<double> controller;
  late final Animation<double> opacity;
  late final Animation<double> width;
  late final Animation<double> height;

  StaggeredAnimation({required this.controller}) {
    opacity = Tween<double>(
      begin: 0.0,
      end: 1.0,
    ).animate(
      CurvedAnimation(
        parent: controller,
        curve: Interval(0.0, 0.100, curve: Curves.ease),
      ),
    );
  }
}

class MyPainter extends CustomPainter {
  @override
  void paint(Canvas canvas, Size size) {
    final paint = Paint()
      ..color = Colors.blue
      ..strokeWidth = 4
      ..style = PaintingStyle.stroke;

    canvas.drawCircle(
      Offset(size.width / 2, size.height / 2),
      100,
      paint,
    );
  }

  @override
  bool shouldRepaint(CustomPainter oldDelegate) => false;
}

void drawCurve(Canvas canvas, Size size) {
  var path = Path();
  path.moveTo(0, size.height / 2);
  path.quadraticBezierTo(
    size.width / 2,
    0,
    size.width,
    size.height / 2,
  );
  canvas.drawPath(path, paint);
}

class Particle {
  Offset position;
  double speed;
  double theta;
  Color color;

  void update() {
    final dx = speed * cos(theta);
    final dy = speed * sin(theta);
    position += Offset(dx, dy);
  }

  void draw(Canvas canvas) {
    final paint = Paint()..color = color;
    canvas.drawCircle(position, 2, paint);
  }
}

final shader = LinearGradient(
  colors: [Colors.blue, Colors.red],
).createShader(Rect.fromLTWH(0, 0, size.width, size.height));

final paint = Paint()..shader = shader;

RepaintBoundary(
  child: CustomPaint(
    painter: MyPainter(),
  ),
)

class CachedPainter extends CustomPainter {
  ui.Picture? _cachedPicture;

  void _createCachedPicture(Size size) {
    final recorder = ui.PictureRecorder();
    final canvas = Canvas(recorder);
    // Draw complex stuff
    _cachedPicture = recorder.endRecording();
  }
}

// Model
class User {
  final String name;
  final String email;
  User(this.name, this.email);
}

// Controller
class UserController {
  void updateUser(User user) {
    // Logic xử lý
  }
}

// View
class UserView extends StatelessWidget {
  // UI components
}

class UserViewModel extends ChangeNotifier {
  User _user;
  User get user => _user;

  void updateUser(User newUser) {
    _user = newUser;
    notifyListeners();
  }
}

abstract class UserRepository {
  Future<User> getUser(int id);
  Future<void> saveUser(User user);
}

class UserRepositoryImpl implements UserRepository {
  final RemoteDataSource remote;
  final LocalDataSource local;
  
  UserRepositoryImpl(this.remote, this.local);
  
  @override
  Future<User> getUser(int id) async {
    // Implementation
  }
}

class ApiClient {
  static final ApiClient _instance = ApiClient._internal();
  
  factory ApiClient() {
    return _instance;
  }
  
  ApiClient._internal();
}

abstract class Button {
  void render();
}

class ButtonFactory {
  static Button createButton(String type) {
    switch (type) {
      case 'material':
        return MaterialButton();
      case 'cupertino':
        return CupertinoButton();
      default:
        throw Exception('Unknown button type');
    }
  }
}

class DataStream {
  final _controller = StreamController<Data>();
  
  Stream<Data> get stream => _controller.stream;
  
  void updateData(Data data) {
    _controller.sink.add(data);
  }
}

class UserBuilder {
  String? name;
  String? email;
  
  UserBuilder setName(String name) {
    this.name = name;
    return this;
  }
  
  User build() {
    return User(name!, email!);
  }
}

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await Firebase.initializeApp(
    options: DefaultFirebaseOptions.currentPlatform,
  );
  runApp(MyApp());
}

Future<UserCredential> signUpWithEmail(String email, String password) async {
  try {
    return await FirebaseAuth.instance.createUserWithEmailAndPassword(
      email: email,
      password: password,
    );
  } on FirebaseAuthException catch (e) {
    throw _handleAuthError(e);
  }
}

Future<UserCredential> signInWithEmail(String email, String password) async {
  try {
    return await FirebaseAuth.instance.signInWithEmailAndPassword(
      email: email,
      password: password,
    );
  } on FirebaseAuthException catch (e) {
    throw _handleAuthError(e);
  }
}

// Thêm dữ liệu
Future<void> addUser(String userId, Map<String, dynamic> userData) async {
  await FirebaseFirestore.instance
      .collection('users')
      .doc(userId)
      .set(userData);
}

// Đọc dữ liệu
Future<DocumentSnapshot> getUser(String userId) async {
  return await FirebaseFirestore.instance
      .collection('users')
      .doc(userId)
      .get();
}

// Cập nhật dữ liệu
Future<void> updateUser(String userId, Map<String, dynamic> newData) async {
  await FirebaseFirestore.instance
      .collection('users')
      .doc(userId)
      .update(newData);
}

// Xóa dữ liệu
Future<void> deleteUser(String userId) async {
  await FirebaseFirestore.instance
      .collection('users')
      .doc(userId)
      .delete();
}

Stream<QuerySnapshot> getUsersStream() {
  return FirebaseFirestore.instance
      .collection('users')
      .snapshots();
}

// Sử dụng trong Widget
StreamBuilder<QuerySnapshot>(
  stream: getUsersStream(),
  builder: (context, snapshot) {
    if (snapshot.hasError) {
      return Text('Có lỗi xảy ra');
    }
    if (snapshot.connectionState == ConnectionState.waiting) {
      return CircularProgressIndicator();
    }
    return ListView(
      children: snapshot.data!.docs.map((doc) {
        return ListTile(
          title: Text(doc['name']),
        );
      }).toList(),
    );
  },
)

Future<String> uploadFile(File file, String path) async {
  try {
    final ref = FirebaseStorage.instance.ref().child(path);
    final uploadTask = ref.putFile(file);
    final snapshot = await uploadTask.whenComplete(() {});
    return await snapshot.ref.getDownloadURL();
  } catch (e) {
    throw Exception('Lỗi khi upload file: $e');
  }
}

Future<void> downloadFile(String url, String localPath) async {
  try {
    final ref = FirebaseStorage.instance.refFromURL(url);
    final file = File(localPath);
    await ref.writeToFile(file);
  } catch (e) {
    throw Exception('Lỗi khi download file: $e');
  }
}

// Provider Example
class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return ChangeNotifierProvider(
      create: (context) => MyState(),
      child: MaterialApp(
        home: MyHomePage(),
      ),
    );
  }
}

static const platform = MethodChannel('samples.flutter.dev/battery');

// Gọi native code
final int result = await platform.invokeMethod('getBatteryLevel');

// Model
class Counter with ChangeNotifier {
  int _count = 0;
  int get count => _count;

  void increment() {
    _count++;
    notifyListeners();
  }
}

// Widget sử dụng Provider
class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return ChangeNotifierProvider(
      create: (_) => Counter(),
      child: Consumer<Counter>(
        builder: (context, counter, child) => Text('${counter.count}'),
      ),
    );
  }
}

// Events
abstract class CounterEvent {}
class IncrementEvent extends CounterEvent {}

// State
class CounterState {
  final int count;
  CounterState(this.count);
}

// Bloc
class CounterBloc extends Bloc<CounterEvent, CounterState> {
  CounterBloc() : super(CounterState(0)) {
    on<IncrementEvent>((event, emit) {
      emit(CounterState(state.count + 1));
    });
  }
}

// Controller
class CounterController extends GetxController {
  var count = 0.obs;
  
  void increment() => count++;
}

// Widget
class CounterWidget extends StatelessWidget {
  final controller = Get.put(CounterController());
  
  @override
  Widget build(BuildContext context) {
    return Obx(() => Text('${controller.count}'));
  }
}

// Provider definition
final counterProvider = StateNotifierProvider<Counter, int>((ref) => Counter());

class Counter extends StateNotifier<int> {
  Counter() : super(0);
  void increment() => state++;
}

// Widget
class CounterWidget extends ConsumerWidget {
  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final count = ref.watch(counterProvider);
    return Text('$count');
  }
}

// Class cần test
class Calculator {
  int add(int a, int b) => a + b;
}

// Test file
import 'package:test/test.dart';

void main() {
  group('Calculator', () {
    late Calculator calculator;

    setUp(() {
      calculator = Calculator();
    });

    test('add should return correct sum', () {
      expect(calculator.add(2, 3), equals(5));
    });
  });
}

testWidgets('Counter increments smoke test', (WidgetTester tester) async {
  await tester.pumpWidget(MyApp());
  expect(find.text('0'), findsOneWidget);
  expect(find.text('1'), findsNothing);

  await tester.tap(find.byIcon(Icons.add));
  await tester.pump();

  expect(find.text('0'), findsNothing);
  expect(find.text('1'), findsOneWidget);
});

void main() {
  IntegrationTestWidgetsFlutterBinding.ensureInitialized();

  testWidgets('Complete flow test', (WidgetTester tester) async {
    await tester.pumpWidget(MyApp());

    // Login flow
    await tester.enterText(
      find.byKey(Key('username')), 
      'testuser'
    );
    await tester.enterText(
      find.byKey(Key('password')), 
      'password123'
    );
    await tester.tap(find.byType(ElevatedButton));
    await tester.pumpAndSettle();

    // Verify home screen
    expect(find.text('Welcome'), findsOneWidget);
  });
}

// Tạo mock class
@GenerateMocks([HttpClient])
void main() {
  late MockHttpClient mockHttpClient;

  setUp(() {
    mockHttpClient = MockHttpClient();
  });

  test('fetchData returns data on success', () async {
    when(mockHttpClient.get(any))
        .thenAnswer((_) async => Response('{"data": "test"}', 200));
    
    final result = await DataService(mockHttpClient).fetchData();
    expect(result, equals('test'));
  });
}

const MyWidget(
  key: Key('my_widget'),
  child: Text('Hello'),
)

AnimatedBuilder(
  animation: controller,
  builder: (context, child) {
    return Transform.translate(
      offset: Offset(0, animation.value),
      child: child,
    );
  },
  child: const MyWidget(), // Cached
)

class User {
  final int id;
  final String name;
  final String email;

  User({
    required this.id,
    required this.name,
    required this.email,
  });

  factory User.fromJson(Map<String, dynamic> json) {
    return User(
      id: json['id'],
      name: json['name'],
      email: json['email'],
    );
  }
}

class ApiService {
  final client = http.Client();
  final baseUrl = 'https://api.example.com';

  Future<List<User>> getUsers() async {
    try {
      final response = await client.get(
        Uri.parse('$baseUrl/users'),
        headers: {'Authorization': 'Bearer token'},
      );
      
      if (response.statusCode == 200) {
        final List<dynamic> data = json.decode(response.body);
        return data.map((json) => User.fromJson(json)).toList();
      } else {
        throw Exception('Lỗi lấy dữ liệu: ${response.statusCode}');
      }
    } catch (e) {
      throw Exception('Lỗi kết nối: $e');
    }
  }
}

class UserProvider extends ChangeNotifier {
  final _apiService = ApiService();
  List<User> _users = [];
  bool _loading = false;
  String? _error;

  Future<void> fetchUsers() async {
    try {
      _loading = true;
      notifyListeners();
      
      _users = await _apiService.getUsers();
      _error = null;
    } catch (e) {
      _error = e.toString();
    } finally {
      _loading = false;
      notifyListeners();
    }
  }
}

class UsersScreen extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Consumer<UserProvider>(
      builder: (context, provider, child) {
        if (provider._loading) {
          return CircularProgressIndicator();
        }
        
        if (provider._error != null) {
          return Text('Lỗi: ${provider._error}');
        }

        return ListView.builder(
          itemCount: provider._users.length,
          itemBuilder: (context, index) {
            final user = provider._users[index];
            return ListTile(
              title: Text(user.name),
              subtitle: Text(user.email),
            );
          },
        );
      },
    );
  }
}