카테고리 보관물: 안드로이드

다트의 call by sharing이 플러터에서 작동하는 원리에 대한 해설

프로그래밍 기술은 소프트웨어 연구에 의해 성립된 개념에 의해 구현됩니다. 함수를 호출한다고 했을때, 매개변수가 넘겨진다면 이 매개변수를 넘겨서 참조하는 방법도 경우에 따라 차이가 있으며 이를 개념화한 것이 언어의 특징으로 규정되어 있습니다. “값에 의한 호출” (call by value) “메모리 주소에 의한 호출” (call by reference) “공유에 의한 호출” (call by sharing) 이 그 개념들입니다.

이들 세가지 개념은 데이터가 함수 범위 내에서 어떻게 접근되고 수정될 수 있는지를 결정하며 프로그램이 어떻게 작동할 것인지를 예측하게 해줍니다.

sum(a, b);

와 같은 구문이 실행될때 a와 b는 sum()에서 어떤 매커니즘으로 작동할까요?

값에 의한 참조는 호출자의 효력 범위(scope)에 있는 변수의 값만 복사해서 함수 내부의 변수에 대입하는 방식으로 동작합니다. 아래 예처럼 변수명과 타입이 같더라도 메모리 공간이 분리된 다른 변수이고, 이 다른 변수에 값만 복사해서 작동하게 됩니다.

int a = 1;
int b = 3;
void sum(int a, int b) {
    a = 4;
    print(a + b); // 4 + 3 = 7 
}

print(a); // 1 (sum()의 값 변경에 영향을 안받음)
print(a + b); // 1 + 3 = 4 

반면 참조에 의한 호출은 호출자의 효력 범위에 있는 변수의 메모리 주소를 함수 내부의 변수에 대입하는 방식으로 작동합니다. 함수 내부에 넘겨진 매개변수는 호출자의 효력 범위에 있는 함수 외부의 변수의 메모리 주소를 가리키기만 하기에, 한 값이 바뀌면 다른 값도 똑같이 바뀌게 됩니다.

int a = 1;
Int b = 3;
void sum(int &a, int &b) {
    a = 2;
    b = 4;
    print(a + b);
}

print(a); // 2
print(b); // 4
print(a + b); // 6

값에 의한 호출의 장점은 직관적이라는 것이구요. 지역 변수와 그보다 상위에 있는 스코프의 변수가 서로 다른 값을 가지게 할 수 있다는데 있습니다. 단점은 거대한 배열 변수나, 복잡한 객체를 넘기는 경우, 처리하는 연산에 필요한 시간과 자원이 늘어나서 오버헤드가 있게 된다는 것입니다. 그래서 참조에 의한 호출이 고안되었던 것입니다. 각 변수가 담은 값의 크기가 크더라도 매개변수로 넘겨진 변수는 해당 변수의 메모리 주소만 가리키기에 처리할때의 오버헤드가 줄어듭니다. 값으로 넘기면 같은 크기의 데이터로 중복되지만, 참조로 넘기면 메모리 주소 크기만큼만 차지하니까요.

이를 절충한 공유에 의한 호출(call by sharing)은 매개변수로 넘기는 것은 객체에 대한 참조값입니다. 호출자의 변수와 함수의 매개변수는 각각 별개의 변수이지만 둘다 동일한 객체를 가리키는 참조의 복사본이 됩니다.

객체가 변경 가능한 객체라면 함수는 전달받은 참조를 통해 이 객체의 내부 상태를 바꿀 수 있습니다. 이 변경 사항은 호출자에게도 그대로 보여집니다. call by reference와 유사한 동작입니다. 반면 함수 내에서 매개변수에 새로운 객체를 할당하는 등의 작업이 일어나면 이는 함수 내의 지역 참조 변수가 가리키는 대상만 바꿉니다. 호출자의 원본 변수는 여전히 원래의 객체를 가리키고 있으며, 아무런 영향을 받지 않습니다. call by value와 유사한 작동입니다.

내부적으로 처리될때는

• 함수는 객체의 참조를 값으로 전달받는다
• 원본 참조에 대한 포인터가 아니라 값 자체의 복사본을 받는다
• 변수가 두 메모리 공간에 분리되어 있어서 call by value의 이점을 지니지만, value의 메모리 주소를 가리키므로 두 변수를 상관적으로 바꾸면 둘다 효력이 있게 할 수 있다
• 이 동작은 호출자 객체의 상태가 변경되는지의 차이인데, 객체가 변경가능한 경우로 한정된다

다트는 call by sharing 전략을 씁니다. 다트 언어 설계의 특징은 원시 타입과 객체 타입을 구분하지 않고 모두 객체로 처리됩니다. int, double, bool, String, Function, null까지도 포함됩니다. “이것이 원시 타입이면 이렇게 동작하고, 객체 타입이면 저렇게 동작한다”와 같은 규칙이 없습니다.

다트에서는 변수란 객체의 데이터 자체를 담고 있는 컨테이너가 아니라 메모리에 존재하는 객체 참조를 저장합니다.

var age =”34″; 라는 코드는 age라는 변수가 “34”라는 값을 가진 String 객체의 참조를 담고 있음을 의미합니다.

반면 var age = 34라는 코드는 age라는 변수가 34라는 정수형 값을 가진 int 객체의 참조를 담고 있음을 의미합니다.

• 호출자의 스코프에 있는 변수는 특정 객체를 가리키는 참조를 가지고 있다
• 함수가 호출되면, 함수의 매개변수를 위한 새로운 변수가 생성된다
• 호출자 변수가 가지고 있던 참조 메모리 주소가 복사되어 새로운 매개변수에 할당된다
• 결과적으로, 호출자의 변수와 함수의 매개변수는 서로 다른 변수이지만, 둘다 정확히 어떤 객체를 가리키게 된다. 즉 객체가 두 스코프 간에 공유되는 것이다.

다트와 플러터 상에서 이 작동을 보여주는 코드 예시와 설명은 복잡하니 생략하구요. 요점은 다트는 call by sharing 방식을 채택한 언어라, 이에 의한 작동상의 이점이 있다는 것입니다.

int 를 전달하든, List를 전달하든, Function을 전달하든, 그 기저에 깔린 원리는 “참조의 복사본을 전달한다”이고 이는 값에 의한 호출과 참조에 의한 호출의 장점을 모두 갖습니다.

플러터에 적용되면, 선언적 UI에 적용됩니다.

개발자는 특정 상태가 되면 UI가 어떻게 보여야 하는지를 기술하고 프레임워크는 상태 변경에 따른 화면 업데이트를 책임집니다. 이 때 중요한 것은 위젯은 불변 객체라는 것입니다. 상태가 변경되면, 위젯 트리를 수정하는 것이 아니라, 새로운 상태를 반영하는 새로운 위젯 트리가 생성됩니다. 그러면 프레임워크는 이전 트리와 새로운 트리를 비교하여 실제 렌더링에 필요한 최소한의 변경만을 수행합니다. (이 단락은 인공지능 답변 참조)

만약 다트가 call by value만 쓴다면, 부모 위젯이 자식 위젯을 전달할때마다 해당 자식 위젯과 그 하위 트리에 대한 깊은 복사(deep copy)가 필요하게 되어 엄청난 계산 비용을 유발하고 프레임워크의 성능을 파괴했을 것입니다. (이 단락은 인공지능 답변 참조)

하지만 다트는 call by sharing 전략을 채택하기에, 객체 생성시 가벼운 참조만 전달됩니다. 객체 복사 과정이 일어나지 않습니다. 그래서 플러터가 지향하는 선언적 UI의 성능의 이점이 있게 되는 것입니다.

마지막으로 구글 Gemini가 정리한 결론부의 언급을 소개하며 마칩니다.

“
다트는 명백히 Call-by-Sharing을 사용합니다. 이는 인자로 전달된 객체를 가리키는 참조의 복사본을 함수에 전달하는 방식입니다. 이로 인해 함수는 공유된 객체의 내부 상태를 변경할 수는 있지만, 호출자의 변수 자체가 다른 객체를 가리키도록 재할당할 수는 없습니다.

이 선택은 의도적인 설계의 결과입니다. Call-by-Sharing은 단순한 기술적 구현 세부사항이 아니라, 다트 언어 설계의 핵심 철학을 반영하는 근본적인 결정입니다. 이는 대용량 객체 전달의 성능 문제(Call-by-Value의 단점)와 예측 불가능한 부수 효과(Call-by-Reference의 단점) 사이에서 실용적인 균형을 맞추려는 의도적인 타협점입니다.

언어 모델의 단순성과 일관성을 강화합니다. ‘모든 것은 객체다’라는 원칙과 결합된 단일 매개변수 전달 규칙은 개발자가 데이터 타입에 따라 다른 동작을 암기할 필요가 없게 하여, 언어의 학습 곡선을 낮추고 코드의 예측 가능성을 높입니다.

플러터의 선언적 아키텍처를 가능하게 하는 핵심 동력입니다. 플러터의 불변 위젯과 ‘상태가 변하면 새로 그린다’는 패러다임은, 위젯 객체의 참조를 값싸게 전달할 수 있는 Call-by-Sharing이 없었다면 성능적으로 불가능했을 것입니다. 또한, 단방향 데이터 흐름을 구현하고, 불변 상태 관리 패턴과의 시너지를 통해 고도로 최적화된 UI 업데이트를 실현하는 기술적 기반이 됩니다.

결론적으로, 다트의 저수준 매개변수 전달 방식과 플러터의 고수준 프레임워크 아키텍처는 분리된 개념이 아니라, 서로를 가능하게 하고 강화하는 불가분의 관계에 있습니다. Call-by-Sharing이라는 잘 설계된 언어적 기반 위에서 플러터의 성공적인 반응형, 선언적 UI 아키텍처가 구축될 수 있었던 것입니다. 이 원리를 깊이 이해하는 것은 플러터 개발자가 더 효율적이고, 안정적이며, 예측 가능한 애플리케이션을 설계하고 구현하는 데 있어 필수적인 통찰을 제공합니다.”

오타가 있어서 다시 올립니다.


덧붙이자면 다트에서 call by sharing은 변수의 메모리 공간은 분리되어 있고, 가리키는 메모리 주소 참조값이 복사된다는 것입니다. 그래서 함수 내에서 불변이면, 본래 변수와 값이 유지되고, 함수 내에서 바꾸면 본래 변수와 값이 달라지게 됩니다.

결국 call by reference와 call by value를 처리하는 동등한 원리가 되죠.

just_audio로 배경음악 연주하는 코드들 해설

플러터에서 배경음악 연주를 할때 중요한 것은 지연시간입니다.

음악 연주를 하다가 화면이 바뀔때 다른 배경음악을 연주해야 한다면 아래와 같은 현상이 있게 됩니다.

  • 재생이 끝나고 다음 재생을 시작할때까지의 지연시간이 생각보다 긴 경우가 있게 됨

이 지연시간을 줄인 패키지가 just_audio입니다. just_audio는 지연시간이 1초보다 작아서 활용에 유리합니다. 지원되는 플랫폼은 Android, iOS, macOS, Web으로 윈도우는 지원을 안하는 것 같애요. 그래도 안드로이드와 iOS가 지원되서 좋습니다.

사용법은 매우 쉬운 편인데요. 함수가 간결하고 직관적입니다. 미디어 플레이어처럼 UI를 세심하게 만들지 않는다면 아래와 같은 함수로도 재생이 됩니다.

  • AudioPlayer()로 재생기 객체 생성
  • AudioSource.asset()으로 재생할 파일 지정
  • ConcatenatingAudioSource()로 여러 파일 연속 재생 소스 설정
  • setAudioSource()로 재생 소스를 객체에 넘김
  • setLoopMode()로 반복재생 설정
  • play() 함수로 재생 시작
  • pause() 함수로 재생 잠시 중단
  • play() 함수로 이어서 재생 (재생 시작 함수와 같음)

이 기반에서 아래와 같은 소스코드를 작성해볼 수 있습니다.

import 'package:just_audio/just_audio.dart';

class BGMAudioPlayer {
  // 오디오 플레이어 인스턴스 생성
  static final _player = AudioPlayer();

  // MP3 파일 목록 (assets/audio/ 폴더 기준)
  static final List<String> _mp3Files = [
    'bgm1.mp3',
    'bgm2.mp3',
    'bgm3.mp3',
    'bgm4.mp3',
    'bgm5.mp3',
    'bgm6.mp3',
    'bgm7.mp3',
    'bgm8.mp3',
    'bgm9.mp3',
    'bgm10.mp3',
    'bgm11.mp3',
    'enka1.mp3',
    'enka2.mp3',
    'enka3.mp3',
    'enka4.mp3',
    'versus.mp3',
  ];

  static late final List<String> _path = List<String>.filled(_mp3Files.length, "");

  static List<int> index = List<int>.filled(_mp3Files.length, -1);

  static shuffleData() {
    for (int i = 0; i < _mp3Files.length; i++) {
      index[i] = i;
    }
    index.shuffle();

    for (int i = 0; i < _mp3Files.length; i++) {
      _path[i] = _mp3Files[index[i]];
    }
  }

  static Future<void> playBackgroundMusic() async {
    try {
      // 1. 재생 목록 셔플
      shuffleData();

      // 2. 셔플된 목록으로 연속 재생 소스(Playlist) 생성
      final playlist = ConcatenatingAudioSource(
        children: _path
            .map((fileName) => AudioSource.asset('assets/audios/$fileName'))
            .toList(),
      );
      // 3. 플레이어에 재생 목록 설정
      await _player.setAudioSource(playlist);

      // 4. 전체 목록 반복 재생 설정
      _player.setLoopMode(LoopMode.all);

      // 5. 재생 시작
      _player.play();
    } catch (e) {
      // 오류 처리
      print("Error occurred while playing audios: $e");
    }
  }

  static Future<void> pauseBackgroundMusic() async {
    try {
      await _player.pause();
    } catch (e) {
      print("Error occurred while pausing audios: $e");
    }
  }

  static Future<void> resumeBackgroundMusic() async {
    try {
      await _player.play();
    } catch (e) {
      print("Error occurred while pausing audios: $e");
    }
  }

  static Future<void> nextBackgroundMusic() async {
    try {
      await _player.seekToNext();
      await _player.play();
    } catch (e) {
      print("Error occurred while seek to next audios: $e");
    }
  }

  static Future<void> prevBackgroundMusic() async {
    try {
      await _player.seekToPrevious();
      await _player.play();
    } catch (e) {
      print("Error occurred while seek to next audios: $e");
    }
  }
  static Future<void> dispose() async {
    try {
      await _player.dispose();
    } catch (e) {
      print("Error occurred while diposing AudioPlayer: $e");
    }
  }
}

이렇게 해두고

@override
void initState() {
  …
 BGMAudioPlayer.play();
  …
}

처럼 기재해서 실행하면 배경음악이 연주되구요.

@override
void dispose() {
  // 생명주기 감지기 해제 및 플레이어 dispose (메모리 누수 방지)
  WidgetsBinding.instance.removeObserver(this);
  super.dispose();
}

// 앱 생명주기 변경 시 호출되는 메서드
@override
void didChangeAppLifecycleState(AppLifecycleState state) {
  super.didChangeAppLifecycleState(state);
  switch (state) {
    case AppLifecycleState.resumed:
      // 앱이 다시 활성화되면 음악 재생
      BGMAudioPlayer.resumeBackgroundMusic();
      break;
    case AppLifecycleState.inactive:
    case AppLifecycleState.paused:
    case AppLifecycleState.hidden:
      // 앱이 비활성화되거나 백그라운드로 가면 음악 일시정지
      BGMAudioPlayer.pauseBackgroundMusic();
      break;
    case AppLifecycleState.detached:
      // 앱이 종료되면 플레이어 리소스 해제
      BGMAudioPlayer.dispose();
      break;
  }
}

처럼 각 화면 담당 State<>() 안에 두면 대기상태가 되면 잠시 음악을 멈추고, 앱이 종료되면 dispose()가 되게 할 수 있습니다. WidgetsBindingObserver를 쓰는 방법인데 State<> 선언 시그니처에

class _SongTitleGameScreenState extends State<SongTitleGameScreen> with WidgetsBindingObserver {
…
}

처럼 해두어야 쓸 수 있구요. initState()에

@override
void initState() {
  super.initState();
  WidgetsBinding.instance.addObserver(this);
  BGMAudioPlayer.resumeBackgroundMusic();
}

처럼 addObserver()를 시작해두어야 합니다.

이 WidgetsBindingObserver를 안쓰면 앱을 대기상태로 두어도 음악이 재생되기에 방해가 되니 꼭 추가해두어야 합니다.

  • 구글 Gemini로 기능 질문을 하니 금방 해결되었습니다.

[플러터] just_audio 패키지로 효과음 지연 시간없이 재생하는 방법 해설

타국어로 썼던 글을 직접 번역하기가 귀찮아서 이번글은 그록한테 번역을 맡겼습니다. 번역 품질이 좋네요. 오타가 몇군데 있을 수도 있으니 주의하시길요.


just_audio (https://pub.dev/packages/just_audio)는 Android, iOS, macOS, 웹, Linux, Windows용 기능이 풍부한 오디오 플레이어입니다.

가장 뛰어난 기능은 재생 모드를 재설정하는 데 매우 낮은 지연 시간을 가진다는 점으로, 길고 복잡한 연결 해제, 해체, 재설정 과정 없이 다음 오디오를 준비하는 데 1초 미만만 필요합니다.

짧은 시간 간격으로 짧은 음향 효과를 재생하고자 하는 프로그래머에게 가장 적합한 선택입니다.

이를 사용하기 위해 따라야 할 몇 가지 사항이 있으며, 이 글에서는 그 방법을 소개합니다.

dependencies:
  just_audio: ^0.9.36

assets:
  assets/audios/

위는 pubspec.yaml에 의존성을 추가하는 방법입니다. just_audio를 의존성 목록에 추가하고 오디오 파일이 저장될 에셋 디렉토리를 설정한 뒤, pub get 명령어를 실행하면 사용할 준비가 됩니다.

import 'package:just_audio/just_audio.dart';

class AudioManager {
  static final AudioPlayer _player = AudioPlayer();

  static Future<void> preloadAudio(String assetPath) async {
    await _player.setAsset(assetPath); // 에셋 미리 로드
  }

  static Future<void> playAudio() async {
    await _player.play(); // 즉시 재생
  }
}

위는 just_audio가 작동하는 최소 예제입니다. 먼저 AudioPlayer() 생성자를 사용하여 just_audio 인스턴스를 만들어야 합니다. 다음으로, 로컬 오디오 에셋에 대해 setAsset을 설정하여 실제 음향 효과 파일을 매개변수로 지정하고 미리 로드합니다. just_audio 인스턴스의 play() 메서드는 setAsset() 메서드에서 설정된 파일을 재생할 수 있습니다.

이와 함께 몇 가지 고려 사항을 추가하여 더 잘 작동하도록 코드를 확장할 수 있습니다.

import 'package:just_audio/just_audio.dart';
import 'package:go_router/go_router.dart';
import 'package:flutter/material.dart';

class AudioManager {
  static final List<AudioPlayer> _players = [
    AudioPlayer(),
    AudioPlayer(),
    AudioPlayer(),
    AudioPlayer(),
  ];

  static const Map<int, String> _audioPaths = {
    0: 'audios/splash.mp3',
    1: 'audios/welcome.wav',
    2: 'audios/applaude.wav',
    3: 'audios/dingding.wav',
  };

  static Future<void> audioInit() async {
    try {
      print('플레이어 0 초기화: ${_audioPaths[0]}');
      await _players[0].setAsset(_audioPaths[0]);
      print('플레이어 1 초기화: ${_audioPaths[1]}');
      await _players[1].setAsset(_audioPaths[1]);
      print('플레이어 2 초기화: ${_audioPaths[2]}');
      await _players[2].setAsset(_audioPaths[2]);
      print('플레이어 3 초기화: ${_audioPaths[3]}');
      await _players[3].setAsset(_audioPaths[3]!);
      print('오디오 초기화 완료');
    } catch (e) {
      print('오디오 초기화 실패: $e');
    }
  }

  static Future<void> splashAudio() async {
    print('스플래시 재생 시작: ${DateTime.now()}');
    await _players[0].setVolume(1.0);
    await _players[0].play().then((_) => print('스플래시 재생 성공'));
    _players[0].playerStateStream.listen((state) {
      if (state.processingState == ProcessingState.completed) {
        _players[0].stop();
        print('스플래시 재생 완료: ${DateTime.now()}');
      }
    });
  }

  static Future<void> welcomeAudio() async {
    print('환영 음향 재생 시작: ${DateTime.now()}');
    await _players[1].setVolume(1.0);
    await _players[1].play().then((_) => print('환영 음향 재생 성공'));
    _players[1].playerStateStream.listen((state) {
      if (state.processingState == ProcessingState.completed) {
        _players[1].stop();
        print('환영 음향 재생 완료: ${DateTime.now()}');
      }
    });
  }

  static Future<void> applaudeAudio() async {
    print('박수 재생 시작: ${DateTime.now()}');
    await _players[2].setVolume(1.0);
    await _players[2].play().then((_) => print('박수 재생 성공'));
    _players[2].playerStateStream.listen((state) {
      if (state.processingState == ProcessingState.completed) {
        _players[2].stop();
        print('박수 재생 완료: ${DateTime.now()}');
      }
    });
  }

  static Future<void> dingdingAudio() async {
    print('딩딩 재생 시작: ${DateTime.now()}');
    await _players[3].setVolume(1.0);
    await _players[3].play().then((_) => print('딩딩 재생 성공'));
    _players[3].playerStateStream.listen((state) {
      if (state.processingState == ProcessingState.completed) {
        _players[3].stop();
        print('딩딩 재생 완료: ${DateTime.now()}');
      }
    });
  }
}

위는 잘 작동하는 응용 가능한 최소 예제입니다.

static final List<AudioPlayer> _players = [
    AudioPlayer(),
    AudioPlayer(),
    AudioPlayer(),
    AudioPlayer(),
  ];

먼저 AudioPlayer 인스턴스를 보유할 List를 선언합니다.

static const List <String> _audioPaths = [
    'assets/audios/splash.mp3',
    'assets/audios/welcome.wav',
    'assets/audios/applaude.wav',
    'assets/audios/dingding.wav',
  ];

파일 경로를 지정하기 위해 String List를 할당합니다. 이는 에셋 루트 디렉토리를 포함한 전체 에셋 경로로 설정해야 합니다.

static Future<void> audioInit() async {
    try {
      print('플레이어 0 초기화: ${_audioPaths[0]}');
      await _players[0].setAsset(_audioPaths[0]);
      print('플레이어 1 초기화: ${_audioPaths[1]}');
      await _players[1].setAsset(_audioPaths[1]);
      print('플레이어 2 초기화: ${_audioPaths[2]}');
      await _players[2].setAsset(_audioPaths[2]);
      print('플레이어 3 초기화: ${_audioPaths[3]}');
      await _players[3].setAsset(_audioPaths[3]);
      print('오디오 초기화 완료');
    } catch (e) {
      print('오디오 초기화 실패: $e');
    }
  }

List와 메서드를 사용하여 오디오 파일을 미리 로드합니다. _players 리스트의 각 요소는 setAsset() 메서드를 호출할 수 있으며, 이는 오디오 경로 리스트의 각 요소를 매개변수로 받아들입니다. 이 예제에서는 _players[i].setAsset(_audioPaths[i])로 충분합니다.

static Future<void> splashAudio() async {
    print('스플래시 재생 시작: ${DateTime.now()}');
    await _players[0].setVolume(1.0);
    await _players[0].play().then((_) => print('스플래시 재생 성공'));
    _players[0].playerStateStream.listen((state) {
      if (state.processingState == ProcessingState.completed) {
      _players[0].stop();
      print('스플래시 재생 완료: ${DateTime.now()}');
    }
    });
  }

다음은 지금까지 작업한 파일을 재생하는 것으로, setVolume(), play(), 그리고 playerStateStream을 사용하여 각 음향 효과가 완전히 완료되었는지 확인합니다. 가장 주목할 점은 재생을 중지할 때 playerStateStream의 state.processingState가 ProcessingState.completed와 같을 때만 stop()을 실행해야 한다는 점입니다. 이를 통해 다음 음향 효과 재생이 이전에 재생된 오디오의 잔여 길이를 재생하지 않도록 방지할 수 있습니다. 이 조건문 안에 넣지 않으면, 예를 들어 splashAudio() 다음에 welcomeAudio()를 재생할 때 잔여 효과가 발생하여 welcomeAudio()가 splashAudio()의 잔여 길이와 함께 출력되므로 바람직하지 않습니다.

이 예제 코드를 사용하지 않으면 제대로 작동하지 않습니다. 예를 들어, 각 재생 메서드의 맨 처음 줄에 _players[0].stop()을 넣으면 제대로 재생되지 않습니다.

static Future<void> splashAudio() async {
    await _players[0].stop(); // 이건 작동하지 않음
    await _players[0].setVolume(1.0);
    await _players[0].play();
  }

이 대신 앞서 예제에서 사용한 state.processingState를 활용하는 방법이 권장됩니다.
이 설정으로 AudioManager.audioInit()와 AudioManager.splashAudio() 등을 호출하면, 이들은 정적 메서드이므로 인스턴스화 과정 없이 프로젝트 소스 코드 어디에서나 직접 호출할 수 있습니다.

이것은 짧은 음향 효과를 재생하고자 할 때의 최소 예제일 수 있으며, 사용자의 목적에 따라 확장하시기 바랍니다.

안드로이드 기기에서 이어폰 소리가 한쪽에서만 나는 문제

보통 이어폰을 막 굴리면서 가지고 다니면 단선이 됩니다. 이 경우 선이 완전히 끊어진게 아니면 소리 재생시 선을 위아래로 움직여보면 양쪽에서 소리가 납니다. 이 경우 완전 단선 위험도 있는데요.

PC나 다른 기기에 이어폰을 옮겨서 들어도 같으면 일단은 이어폰 문제 같지만, 최악의 경우 시스템 파일 변조나 기타 같은 효과의 원인도 있을 수 있습니다. 이 경우 이어폰을 바꿔서 연결해보면 되는데 이 경우에도 잘 되다가 다시 안되기도 하네요.

제 경우 이렇게 하니 복구가 됩니다.

(1) 재생되는 소리를 잠시 멈춘다. (유튜브 영상을 끄는 등의 작업)
(2) 설정에서 초기화 메뉴로 들어가 접근성 초기화를 실행한다.
(3) 다시 소리를 재생한다.

이외에도 접근성 메뉴에 있는 (위 접근성 초기화 메뉴와 다름) 청각보조 메뉴에서 (삼성의 경우입니다) 좌우 소리 균형 항목이나 모노 오디오 항목 등을 살펴보고 조정해서 되면 될 수 있네요.

저는 일단 (1)부터 (3)까지 하니 되었습니다. 중요한 것은 접근성 초기화하기전에 소리 재생을 멈추고 초기화후 다시 재생하는 것인데 메모리 상태와 연관이 있어보입니다. 시스템 파일 변조도 그렇구요. 모종의 이유로 이렇게 될 수도 있는 것 같습니다.

모토롤라 모토 G 5G 2023 스마트폰 리뷰

모바일폰을 대부분의 경우 삼성 최상위 제품을 주로 쓰시는 것 같습니다. 제가 가입해 있는 캐나다 쿠도 모바일의 경우 갤럭시 S23 제품군은 2년 텀계약에 한달에 3만원(33불)씩 내야 하는데요. 이 비용이 부담이 되어 가성비 스마트폰을 주로 봅니다. 삼성 갤럭시 A 시리즈를 눈여겨보구요. 이들 폰에 안드로이드 메이저 버전 업그레이드도 된다고 합니다. 갤럭시 A54와 갤럭시 A14가 있는데요. 찾아보니 둘다 된다고 하네요. 그런데 구하기가 어려워서 대안을 찾아보니 2년 텀계약에 10불인 모토롤라 모토 G 5G 2023이 있었습니다. 흡사한 사양의 삼성 갤럭시 A14는 개통시 일시불로 100불 (9만원)을 내야 하는데 모토롤라 모토 G 5G 2023은 아니었구요. 이 폰 전에 쓰던 모토롤라 엣지를 상당히 잘 썼기에 사양과 가격대를 보고 구입했습니다.

사양은 아래와 같습니다.

눈에 띠는 사양은 249~400불(캐나다화)로 스냅드래곤 480+ 프로세서에 4GB 램, 5000mAh 배터리, 안드로이드 13, 48MP 카메라, 128GB 내장 메모리가 가능하다는 것과, 스크린이 120Hz 주사율이라는 것입니다.

나름대로 사양 배분을 잘 한 것 같구요. 아주 고사양은 아니더라도 용도에 따라 만족하면서 쓸 수 있게 만들어져 있는 것 같습니다.

스냅드래곤 480+ 탑재이구요. 작업시 큰 무리가 없습니다. 게임은 안돌리고 전화나 인터넷, 앱 개발시 실장비 테스트용으로 돌리는 저의 용도에는 그럭저럭 괜찮네요.

디스플레이 해상도가 갤럭시 A14 5G가 조금더 좋고 주사율은 갤럭시 A14 5G가 90Hz로 낮군요. 카메라도 갤럭시 A14가 50MP로 조금 높습니다. 영상 촬영은 똑같이 1080p30 이네요.

화면 해상도는 모토 G 5G 2023이 딸립니다. 720×1600이구요. 내장 저장공간은 제가 구입한 기종은 128GB로 갤럭시 A14 5G보다 좋군요.

디스플레이 주사율이 높아서인지 다른 이유에서인지 화면 전환시 부드러움이 강하게 느껴집니다. 화면은 색감도 부드럽고 눈에 무리가 덜 가는 기분이 들었습니다. 게임할때 주사율이 크게 관여할테지만 게임은 안돌려봤습니다. 게임용으로 나온 사양도 아닌 것 같애요.

디자인은 플라스틱 외장재인데 다른 금속재질과 큰 차이없는 질감으로 마감처리가 좋습니다. 무광택으로 뒷편이 처리되어 있는데 고급지네요. 보통 저가형이면 디자인이 투박한데 모토롤라는 점유율을 높히고 싶은지 세이비하게 잘 만들었습니다. 사소한 부분이지만, 매번 폰 꺼내서 사용할때마다 시각적으로 느낌을 주네요. 그리고 이전에 나온 모토롤라 저가형 폰과 달리 시작 화면 비주얼 효과도 고가형 제품에서 보여주던 고급진 비주얼을 보여줍니다.

램이 4GB로 충분해서 좋습니다. 어떤 리뷰어는 멀티태스킹을 하려고 여러 앱을 실행 상태로 두고 앱들을 실행하면 앱 실행시 버벅인다고도 하고 다른 리뷰어는 충분하다고도 하는데 CPU 문제라네요. 일단 저는 크롬으로 인터넷할때는 앱들을 다른 종류는 종료하고 하는 스타일이라 큰 불편을 못느꼈습니다. 램이 4GB로 충분하니, 앱 한두개 실행하는 것은 커버할 것 같애요. 헤비한 작업은 태블릿을 쓰고, 멀티태스킹은 잘 안하는 경우라면 큰 지장이 없을 것 같구요. 게임 실행이 아니라면 웹브라우저 탭 두세개 정도는 커버할 것 같습니다.

인터넷은 5G가 되구요. 802.11ac입니다. 2.4GHz 802.11n 라우터에 연결해도 속도가 안느리고 LTE+에도 안느렸습니다.

주변기기는 블루투스 5.1로 연결이 되구요. 하단 USB-C 포트로 충전이 되고 이어폰잭은 3.5mm가 제공됩니다.

안드로이드 13 기본 탑재입니다. 그런데 모토롤라가 만든 UI라서 그런지 안드로이드 13이라서 그런지 둥글둥글해보이는 구성요소 그래픽에 화면 색상톤이 부드러운 파스텔톤 같이 느껴집니다. 삼성 태블릿들도 안드로이드 13 업글이 되어 있는데 이런 느낌이 아니네요. 모토 G 5G 2023은 눈이 안아파서 좋은 것 같습니다. 단점은 메뉴 구성이 복잡한 편이라 처음 구입해서 비밀번호 표시가 안되게 하는 메뉴 항목을 찾기가 어려웠네요. 전에 쓰던 폰보다도 더 복잡한 구성 같았습니다. 삼성 폰과 구별되는군요. 시간을 한 40분은 허비했네요.

메뉴 구성 외적으로도 불편한게 모토롤라가 제공하는 UI는 사용성이 익숙해지지 않기에 안드로이드 UI 기본인 하단 세개 버튼 UI로 설정해두었습니다.

요즘 제작중인 앱은 텍스트로 된 정보를 보여주는게 주된 기능이고 정적인 이미지가 있고 애니메이션이 주된 장식은 아닌데요. 나중에 실험해보고 보고를 올려보겠습니다. 네이버나 유튜브가 잘 작동하는 것을 보면 무리없이 돌아갈 것 같습니다. 한가지 성능을 봐야할게 앱에 포함시킬 매칭-3 타일 게임인데요. 각각 100KB 정도 되는 이미지가 49개 로드되어 삭제와 생성을 반복하는 게임인데 어떨지 미확인입니다.

종합해보면 사양이 그런대로 좋고 가격도 저렴해서 메리트가 있습니다. 앱도 타사 저가형 일부모델처럼 일일히 다 수동으로 설치안해도 잘 설치되어 있어서 좋네요. 게임안하시고 인터넷을 주로 하시고 전화 용도로만 쓰신다면 충분히 만족할만 합니다. 화면 해상도가 720×1600이라 후지지만 영상 촬영은 1080p30이 되고 사진 촬영도 48MP이고 무엇보다도 텀계약시 일시불로 100불 안내고 한달에 10불만 내는게 가능해서 가성비가 좋습니다.

일단 이렇게 판단했습니다. 읽어주셔서 감사합니다.

모토롤라 최신 스마트폰에서 비밀번호 입력시 화면 표시 안하기

설정 → 시스템 → 언어 및 입력 → 터치키보드 → Gboard → 환경설정 →키누르기 → 키누를때 팝업 해제
설정 → 보안 및 개인 정보 보호 → 개인 정보 보호 → 개인 정보 보호 설정 → 비밀번호 표시 해제

그냥 찾다보면 안찾아져서 정리해둡니다.

[안드로이드] 안드로이드 앱 용량 줄이기 2

https://shutterpress.info/pc/2023/02/17/%ec%95%88%eb%93%9c%eb%a1%9c%ec%9d%b4%eb%93%9c-%ec%95%b1-%ec%9a%a9%eb%9f%89-%ec%a4%84%ec%9d%b4%ea%b8%b0/

전에 작성했던 글에서 해설하지 않은 부분을 보충합니다.

우선 플러터 작업시 프로젝트 페인에서 android → app → build.gradle 에 아래 라인을 추가합니다. (안드로이드 스튜디오의 경우)

build.gradle의 android { } 블락안에

splits {
    abi {
        reset()
        include("x86", "x86_64", "armeabi")
    }
}

이 라인을 추가합니다. 제가 참고한 네이버 개발자의 말에 의하면 위 구문을 추가시 앱이 크래시 잘된다고 하는데 아마도 구형 기기라서 그런 것 같네요. 크래시 잘 안되는게 일반 같아서 위 라인을 추가해도 되는 것 같습니다. 위 라인 추가후 Run 메뉴에서 Flutter run ‘main.dart’ in Release Mode 로 빌드하면 각각의 아키텍처에 맞는 APK 파일이 생성됩니다. 타깃이 되는 장비에 맞추어 생성이 되는데 이 경우 위 구문의 효력과, 릴리즈 모드 빌드의 효력이 겹쳐서 앱 파일 크기 조정이 더 잘 됩니다.

또한 APK Analyzer를 쓰면 APK 구성 요소 중에서 APK 파일 크기를 차지하는 파일들과 디렉토리 등을 볼 수 있습니다.

https://developer.android.com/studio/build/apk-analyzer?hl=ko

이 도구를 쓰면 크기를 차지하는 구성 요소들을 잘 선별해낼 수 있어서 최적화에 도움됩니다. 사진을 더 압축한다든지 해서 용량 줄이는데 정보를 주기도 하고, 여러 기능이 지윈되니 써볼만합니다. 실행방법은 위 페이지 링크로 가면 나옵니다.

이 글 1편에서 해설한 것과 이 글에서 설명한 것을 다 적용하니 앱이 150MB에서 15.8MB로 줄었네요 ^^ 안드로이드의 경우 그렇습니다.

참고: 위 본문에 언급한 abi “구문의 효력과, 릴리즈 모드 빌드의 효력이 겹쳐서”라는 말의 의미는 각각 효력이 있어서 동시에 적용하면 결국 파일이 더 작아진다는 것을 말하려고 한 언급입니다. 두 방법이 겹치는 특별한 원리가 있는지는 미상인데 일단 각각 효력이 있는 것이 사실이고 둘다 적용하면 APK 파일 크기가 더 작아집니다. 두 방법 중에 하나를 안적용해도 다른 하나는 잘 작동합니다. 둘다 적용하면 더 좋구요. 위에 언급한 표현으로는 두가지 방법이 긴밀한 연관성이 있게 적용된다는 의미가 되는데, 이게 확인은 안되었습니다. 그냥 두가지 방법을 둘다 적용하면 전에 쓴 글에서 소개한 것만 적용한 것에 비해 APK 파일 크기가 더 줄어든다는 의미입니다. 그냥 설명을 하다보니 표현이 애매해져서 참고 사항으로 보충합니다.

플러터에서 앱 화면 구동까지 딜레이 주기 (카운트 다운)

플러터로 가위바위보 게임을 만들고 있습니다. 우선 가위, 바위, 보 중에서 하나를 누르면 선택지가 입력되어 게임이 진행되는 구조인데요. 채점하는 동안 선택지를 더 못고르게 DateTime() 함수로 2초 동안 못고르게 만들었습니다. 그런데 구조적인 문제로 인해 화면이 로딩되고나서 무심코 유저들이 가위, 바위, 보를 탭하다보면 2초간 못고르게 된게 화면 로드할때부터 효력이 있어서 이것저것 누르다보면 UI에 대한 신뢰감이 저하됩니다.

그래서 화면 로드 후 첫로드일때만 3초간 딜레이를 주고 있습니다. 3초부터 0초까지 카운트 다운 합니다.

우선 아래와 같은 코드면 됩니다.

late Timer? _timer;
int count = 3;

void initCountDown() {
    _timer = Timer.periodic(const Duration(seconds: 1), (timer) {
        if (timer.tick == 0) {
            setState(() {
                count = 3;
            });
        }
        if (timer.tick == 1) {
            setState(() {
                count = 2;
            });
        }
        if (timer.tick == 2) {
            setState(() {
                count = 1;
            });
        }
        if (timer.tick == 3) {
            setState(() {
                count = 0;
            });
            _timer?.cancel();
        }
    }
}

코드에서 중요한 것은 _timer 변수를 Timer? 타입으로 지정하고 Timer.periodic(duration) 객체를 담아 1초 간격으로 tick해서 적절한 처리를 하는 원리입니다. _timer 변수는 Timer 객체를 담고, 인자로 주어지는 timer로 tick을 조사합니다. tick은 0부터 시작해서 이 함수에서는 1초 간격으로 늘어나는데, 이를 조건문으로 검사해서 setState() 로 갱신해줍니다.

이렇게 실행하면 UI에서

Text('시작하기까지 $counter 초 남았습니다')

처럼 해둔 위젯에 표시가 갱신됩니다.

이렇게 만든 initCountDown()을 initState() 함수에 기재합니다.

@override
initState() {
    super.initState();
    initCountDown();
}

이 위치 이외에 build() 함수 등에 두면 갱신시마다 initCountDown() 이 실행되어 $counter 부분이 점멸하니 반드시 initState()에서 실행하여 화면 갱신되어도 두번 다시 실행되지 않게 합니다.