사전 앱 클래스 연습

[name27]

main.dart

import 'package:dictionary_app/page/main_page.dart';
import 'package:flutter/material.dart';

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

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      theme: ThemeData.dark(),
      home: MainPage(),
    );
  }
}

main_page.dart

import 'package:dictionary_app/model/dict.dart';
import 'package:dictionary_app/widget/meaningCard.dart';
import 'package:dio/dio.dart';
import 'package:flutter/material.dart';

class MainPage extends StatefulWidget {
  const MainPage({super.key});

  @override
  State<MainPage> createState() => _MainPageState();
}

class _MainPageState extends State<MainPage> {
  String word = '';
  Future<Dict?> getData() async {
    Dio dio = Dio();
    var url = 'https://api.dictionaryapi.dev/api/v2/entries/en/';
    var res = await dio.get(url + word);
    if (res.statusCode == 200) {
      return Dict.fromMap(res.data.first);
    }
    return null;
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Dictionary App'),
        elevation: 0,
        centerTitle: false,
      ),
      body: Center(
        child: SingleChildScrollView(
          physics: NeverScrollableScrollPhysics(),
          child: Column(
            mainAxisAlignment: MainAxisAlignment.center,
            children: <Widget>[
              Row(
                children: [
                  Expanded(
                    child: Padding(
                      padding: const EdgeInsets.all(16),
                      child: TextField(
                        decoration: const InputDecoration(
                          hintText: "Search",
                          suffixIcon: Icon(Icons.search),
                          enabledBorder: OutlineInputBorder(
                            borderSide: BorderSide(color: Colors.white),
                          ),
                          focusedBorder: OutlineInputBorder(
                            borderSide: BorderSide(color: Colors.white),
                          ),
                        ),
                        onSubmitted: (value) {
                          word = value;
                          setState(() {});
                        },
                      ),
                    ),
                  ),
                ],
              ),
              FutureBuilder(
                future: getData(),
                builder: (context, snapshot) {
                  if (snapshot.connectionState == ConnectionState.done) {
                    if (snapshot.data != null) {
                      return MeaningCard(dict: snapshot.data!);
                    } else {
                      return SizedBox();
                    }
                  }
                  return CircularProgressIndicator();
                },
              )
            ],
          ),
        ),
      ),
    );
  }
}

meaningCard.dart

import 'package:dictionary_app/model/dict.dart';
import 'package:flutter/material.dart';

class MeaningCard extends StatelessWidget {
  const MeaningCard({super.key, required this.dict});
  final Dict dict;

  @override
  Widget build(BuildContext context) {
    return Padding(
      padding: const EdgeInsets.all(8.0),
      child: SizedBox(
        height: 450,
        child: ListView(
          physics: BouncingScrollPhysics(),
          children: [
            Padding(
              padding: const EdgeInsets.all(3.0),
              child: Text(
                dict.word,
                style: TextStyle(fontWeight: FontWeight.w600, fontSize: 18),
              ),
            ),
            SizedBox(
              height: 9,
            ),
            Padding(
              padding: const EdgeInsets.all(8.0),
              child: Wrap(
                spacing: 400,
                runSpacing: 3,
                children: [
                  Text(
                    dict.meanings[0].partOfSpeech,
                    style: TextStyle(fontWeight: FontWeight.w600, fontSize: 18),
                  ),
                  Text('-Synonyms:'),
                  for (var synonyms in dict.meanings[0].synonyms)
                    Text(synonyms),
                  SizedBox(
                    height: 8,
                  ),
                  Text('- Definitions:'),
                  for (var definitions in dict.meanings[0].definitions)
                    Text(definitions.definition),
                  SizedBox(
                    height: 8,
                  ),
                  Text('- Antonyms:'),
                  for (var antonyms in dict.meanings[0].antonyms)
                    Text(antonyms),
                ],
              ),
            ),
            Padding(
              padding: const EdgeInsets.all(8.0),
              child: Wrap(
                spacing: 400,
                runSpacing: 3,
                children: [
                  Text(
                    dict.meanings[1].partOfSpeech,
                    style: TextStyle(fontWeight: FontWeight.w600, fontSize: 18),
                  ),
                  Text('-Synonyms:'),
                  for (var synonyms in dict.meanings[1].synonyms)
                    Text(synonyms),
                  SizedBox(
                    height: 8,
                  ),
                  Text('- Definitions:'),
                  for (var definitions in dict.meanings[1].definitions)
                    Text(definitions.definition),
                  SizedBox(
                    height: 8,
                  ),
                  Text('- Antonyms:'),
                  for (var antonyms in dict.meanings[1].antonyms)
                    Text(antonyms),
                ],
              ),
            ),
          ],
        ),
      ),
    );
  }
}

dict.dart

import 'package:dictionary_app/model/license.dart';
import 'package:dictionary_app/model/meaning.dart';
import 'package:dictionary_app/model/phonetic.dart';

class Dict {
  String word;
  String? phonetic;
  List<Phonetic> phonetics;
  List<Meaning> meanings;
  License license;
  List<String> sourceUrls;

  Dict({
    required this.word,
    required this.phonetic,
    required this.phonetics,
    required this.meanings,
    required this.license,
    required this.sourceUrls,
  });

  factory Dict.fromMap(Map<String, dynamic> map) {
    return Dict(
      word: map['word'],
      phonetic: map['phonetic'],
      phonetics:
          List<Phonetic>.from(map['phonetics'].map((e) => Phonetic.fromMap(e))),
      meanings:
          List<Meaning>.from(map['meanings'].map((e) => Meaning.fromMap(e))),
      license: License.fromMap(map['license']),
      sourceUrls: List<String>.from(map['sourceUrls']),
    );
  }
}

license.dart

class License {
  String name;
  String url;

  License({required this.name, required this.url});

  factory License.fromMap(Map<String, dynamic> map) {
    return License(
      name: map['name'],
      url: map['url'],
    );
  }
}

phonetic.dart

import 'package:dictionary_app/model/license.dart';

class Phonetic {
  String? text;
  String audio;
  String sourceUrl;
  License? license;

  Phonetic(
      {required this.text,
      required this.audio,
      required this.sourceUrl,
      required this.license});

  factory Phonetic.fromMap(Map<String, dynamic> map) {
    return Phonetic(
      text: map['text'],
      audio: map['audio'],
      sourceUrl: map['sourceUrl'],
      license: map['license'] == null ? null : License.fromMap(map['license']),
    );
  }
}

meaning.dart

import 'package:dictionary_app/model/definition.dart';

class Meaning {
  String partOfSpeech;
  List<Definition> definitions;
  List<String> synonyms;
  List<String> antonyms;

  Meaning(
      {required this.partOfSpeech,
      required this.definitions,
      required this.synonyms,
      required this.antonyms});

  factory Meaning.fromMap(Map<String, dynamic> map) {
    return Meaning(
      partOfSpeech: map['partOfSpeech'],
      definitions: List<Definition>.from(map['definitions'].map((e) => Definition.fromMap(e))),
      synonyms: List<String>.from(map['synonyms']) ,
      antonyms: List<String>.from(map['antonyms']) ,
    );
  }
}

definition.dart

class Definition {
  String definition;
  List<String> synonyms;
  List<String> antonyms;
  String? example;

  Definition(
      {required this.definition,
      required this.synonyms,
      required this.antonyms,
      required this.example});

  factory Definition.fromMap(Map<String, dynamic> map) {
    return Definition(
      definition: map['definition'],
      synonyms: List<String>.from(map['synonyms']),
      antonyms: List<String>.from(map['antonyms']),
      example: map['example'],
    );
  }
}