ラベル 設計視点 の投稿を表示しています。 すべての投稿を表示
ラベル 設計視点 の投稿を表示しています。 すべての投稿を表示

2015年7月27日月曜日

2Dアニメ機能のライブラリを試作(全体設計編)

iOSのAPIには、かなり簡単に使えるアニメーション機能が含まれています。おかげで、いろいろな箇所へアニメーションを付加することが可能です。

それだけにライブラリ化したい重要な候補なのですが、アニメーションが使われる機能や場面が様々で、汎用的なライブラリ化が難しい対象でもあります。

仕方がないので、特定の用途では十分に使えるアニメーション機能として、ライブラリ化してみました。いつものように、UIViewのサブクラスという形でのライブラリ化です。UIViewの中で、指定したアニメーションが動くというわけです。

UIViewであれば、既存のViewに重ねる方法でアニメーションを加えられます。上へ重ねるだけでなく、下に敷いておけば、アニメーションの背景も簡単に実現できるでしょう。

とりあえず、2Dアニメーションの部分だけ試作してみました。どんな形でライブラリ化したのか、どこまでの機能を付けたのか、どれぐらい使いやすいのか、当初期待したほどは良くないのか、いつものように紹介します。

 

まず最初は、大まかな機能を決めます。基本的には、ある程度まで複雑なアニメーションを作れないと、実用にはならないでしょう。そのためには、複数のアニメ部品がそれぞれ独立して動き、全体のアニメーションを構成する形が必須です。

個々のアニメ部品は、それぞれ別々に動きを設定します。使える動きとしては、移動、拡大縮小、回転、透明度変更は必要でしょう。加えて、等速で動くだけでなく、ゆっくり止まるような動きも使いたいはずです。これは、iOSのAPIに含まれるTiming Functionsという指定で可能です。

個々のアニメ部品の動作では、遅延再生や繰り返し再生も必須でしょう。また、再生前と再生後のそれぞれで、部品表示の有無を選べる機能も大事です。これが使えると、いろいろと応用ができますから(この辺の話は使用例で)。

アニメ部品の動きを組み合わせた全体の動作でも、繰り返し再生は必要です。また、一時停止と再生ができると、ユーザーとの対話に役立ちそうです。さらに、キャンセルも必要でしょう。

アニメーションは、動きの指定だけでは実現できません。動かすアニメ部品を用意する必要があります。部品としては、文字列、画像、UIViewの3つを考えました。文字列は、文字列のまま渡すと、文字列の画像が作られて動かせる形です。画像は、画像そのものを動かす形しかないでしょう。UIViewは自由な部品を作れるので、利用範囲を広げるために必須だと考えました。これらをアプリ側が用意して、アニメ機能のライブラリに渡します。

動作の指定は、いつものように定義データとして用意します。その定義データとアニメ部品(文字列、画像、UIView)を組み合わせて、自由なアニメーションを作れるというライブラリを目指しました。

近い将来、3Dアニメーション機能も追加する予定です。そのとき、2Dと3Dを混在させても動くことが必須です。ですから、3D機能を追加しやすいように、また混在しても動くような内部構造で作る必要があります。

 

以上の話をまとめると、次のようになります。

2Dアニメーション機能に求める機能
・UIViewのサブクラスとして作る
・アニメーションの動作は、定義データとして用意する(簡単に使えること)
・定義データ以外には、文字列、画像、UIViewもアニメ部品として使える
・複数の要素を動かせ、それぞれが独立した動きを指定できる
・個々の要素の動きは単純でも構わないが、それを組み合わせて複雑な動きも作れる
・個々の要素の動作として、移動、拡大縮小、回転、透明度を指定できる
・個々の要素の動作として、Timing Functionsを指定できる
・個々の要素の動作として、遅延再生、繰り返しも可能
・個々の要素の動作として、再生前と動作後に、それぞれ非表示も可能
・組み合わせた全体の動作として、繰り返しも可能
・組み合わせた全体の動作として、一時停止と再開、キャンセルも可能
・内部構造では、3D要素を追加しやすく、また2Dと3Dの要素が混在して動くように最初から配慮する

個々のアニメ部品の動きは単純なものばかりですが、それらを組み合わせて使うと、意外に多くのアニメーションを実現できそうです。実際、凝った動きのアニメーションを使う機会はほとんどないですから、これぐらいの機能でも十分だと思います。

 

機能の整理がまとまったので、実現方法の検討に入ります。iOSのAPIに含まれるアニメーション機能は、いろいろな形で用意されているため、どれを使うのか選択しなければなりません。

改めて、いろいろと調べてみたところ、大事な点が分かりました。UIViewから呼び出せるアニメーション機能は、途中でキャンセルできないと判明したのです(もしかしたら間違っているかもしれません。その場合は、お知らせください)。これで、UIViewのアニメーション機能の採用は不可能になりました。

残った候補の中で、一番使いやすいのがCABasicAnimationでした。簡単に使えるものの、機能が意外に多いのが特長です。API上の位置付けとしては、Core Animationを使いやすくするために用意したAPIという感じでしょうか。

UIViewから呼び出せるアニメーション機能よりも、多くの機能があります。将来的な拡張も容易なので、その点でも安心して採用できます。当然ですが、途中のキャンセルも出来ますし、再生の一時停止や再開も簡単です。

 

以上の話をもとに、これから作るクラスの内部構成を作ってみたら、次のようになりました。

2Dアニメーション機能を持つViewクラスの内部構成
・UIViewのサブクラス
・内部データ:定義データ+表示部品、状態保持(再生中、一時停止中)
・初期化(Viewのサイズ、定義データ+表示部品)
・メソッド:
 ・再生開始(繰り返し回数)
 ・一時停止および再開
 ・再生キャンセル
 ・状態問い合わせ(再生中、一時停止中)
・透明ボタン:一時停止と再開
 ・初期状態ではオフ
 ・メソッド:透明ボタンのオンオフ

見て分かるように、機能としては単純です。アニメーション部分だけ作れれば、そのまま完了する感じですね。

アニメーションの再生では、複数の要素が含まれ、それぞれが異なる動作なので、そこさえキッチリと作れれば大丈夫そうです。また、一時停止や再開も、複数の要素を一緒に扱わなければなりません。

実際に作ってみたら、ソースコードは予想外に長くなりました。クラスの本体部分よりも、データ定義のソースが長くなったからです。使い勝手を良くしようと、いろいろな初期化を用意したためです。

 

とりあえず試作したのは、2Dアニメーションだけです。作り終わって一番苦労したと思った点は、アニメーションの処理ではありませんでした。アニメーションの動きを定義する、データ定義の設計に一番苦労したのです。何度か修正を繰り返しながら、やっと落ち着いたという感じでした。

具体的なソースコードは、次回からの投稿で紹介します。

2015年7月18日土曜日

環境設定機能ライブラリもモデルクラス

先日、友人のIT技術者と飲んだとき、このブログの内容に関して、鋭い指摘を受けました。それは、環境設定機能のライブラリも、モデルクラスに含まれるのではないかとの指摘です。

 

言われてみて気付きましたが、確かにそのとおりです。環境設定機能を実現したライブラリは、環境設定機能を汎用化したクラスですが、環境設定機能というモデルでもあります。

ソートや検索といった機能は、必要が無いので持っていません。しかし、定義されたデータ型で値を保持し、アプリとのやりとりを実現しています。また、設定内容をファイルへ保存したり、保存したファイルから環境設定を読み込んだりもできます。まさに、環境設定機能に特化したモデルクラスと言えるでしょう。

 

環境設定機能ライブラリを作ったときは、どのアプリでも簡単に使える環境設定機能を作ろうと考えただけでした。その時点では、モデルクラスまでライブラリ化しようとは考えていません。また、モデルクラスを作り始めたときは、過去に作ったライブラリのどれかが、モデルクラスに該当するなどとは思ってもいませんでした。そのため、友人に指摘されるまで、モデルクラスに該当するとは気付きませんでした。

モデルクラスのライブラリへ環境設定機能が加わったことで、ライブラリは合計3つになりました。また、今回の指摘によって、ライブラリ化するモデルクラスを探す意味で、視野が広がったと思います。どのアプリでも使いそうな機能を洗い出し、それをモデルクラスとしてライブラリ化できそうに感じています。友人の指摘に、大感謝です。

 

環境設定機能ライブラリですが、作ったときのまま改良していません。その後に作った、別なライブラリも増えました。それらを使って、改良できるはずです。

改良点として真っ先に浮かんだのは、ファイルの読み書きを間接参照にするライブラリの利用です。環境設定機能ライブラリでも、ファイルの読み書きを間接参照にして、特定の保存先に依存しない形に改良できます。修正は簡単なので、余裕ができたら実施する予定です。

 

今回の指摘は、一緒に飲んでるときの普通の話として出てきました。でも、このように鋭い指摘をくれる仲間は、本当にありがたいです。お互いに刺激し合いながら、今後も良い関係を続けたいと思います。

2015年7月7日火曜日

ライブラリ化の当面のゴール

このブログで紹介しているように、Swiftで書いた独自ライブラリを少しずつ作り進めています。まだまだ途中の段階ですが、どんなゴールを描いているのか、簡単に紹介したいと思います。

最初に言っておきますが、これから書く話は、ゲームなどのアプリを作るのが前提ではありません。あくまで業務アプリなどの、遊び要素の少ないアプリの開発に関しての話です。ゲームのアプリなら、大規模な開発ツールが既に作られていて、それを使うのが賢い選択でしょうから。

 

新しいOSや開発ツールを使い始めたとき、独自のライブラリ化を進めるのは、開発経験が長い人なら一般的でしょう。ただ、どのようにライブラリ化するのか、どんなゴールを目指して進めるのかは、人によって異なると思います。

私の場合は、開発やメンテの手間を減らすことです。それにより、開発期間が短くなりますし、完成後のメンテの負荷も小さくなります。とにかく幅広く使えるライブラリを増やして、アプリ開発の手間を大きく減らすことが目的です。

ライブラリとして作ったコードは、単独で十分なテストをされているのに加えて、複数のアプリで使われているため、品質は高く保たれがちです。また、OSやツールのバージョンアップで変更が生じたときも、ライブラリ単体で更新してテストを済ませれば、あとはアプリ側のライブラリを入れ替えるだけです。複数アプリを合計した際の作業量は、かなり減るでしょう。

あと、ライブラリの形式として、ソースコードのままで使う方法を重視しています。ソースコードのままアプリに追加する形なので、ライブラリにバグがあっても簡単に見付かりますし、ライブラリを拡張したくなったときも、可能性が簡単に判断できます。ソースコードのまま追加するものの、基本的にはライブラリに手を加えません。ただし、どうしても手を加えなければならないケースでは、ソースの先頭に変更内容を明記する形で、認めてはいます(実際には、めったにやりません)。当然ながら、ライブラリを改良して対応するのが、第一の選択肢です。

以上は、あくまで、目先の目的としての話です(もっと大きな目的は、最後のほうに出てきます)。

 

いろいろなアプリを作っていると、似たようなコードを数多く書いている自分に気付きます。たいていは1から書かず、前に作ったソースコードをコピーしてから修正するでしょう。コピーによって手間は減っていますが、似たようなコードを書いている現状には変わりません。

そんな風に考えていると、似たようなコードを書かなくて済む方法はないか、深く考えるようになります。部分的にコピーして作るのではなく、ソースコード全体をファイル単位でアプリに持って行き、そのままで使える状態に作れないかと。これがライブラリ化の始まりです。おそらく、独自のライブラリを作っている人は、似たような経験や考えがあるはずです。

実際にライブラリ化を進めると、かなりの効果があると実感できます。似たようなコードを書くことが減り、ライブラリで済ませられる範囲が少しずつ増えていきます。もし既存のライブラリで機能が不足する場合も、ライブラリのほうを拡張して、新しいアプリに対応させます。その結果、ライブラリが適用できる範囲が少しずつ増えていきます。

Swiftを使い始めてから、それほど時間が経過していません。1.0の正式版が登場してからですから、まだ1年未満です。それでも、ライブラリを少しずつ作り続けたので、だんだん充実してきました。モデルクラスのライブラリも2つ作り、ライブラリの対象範囲も広がっています。今後の充実が、ますます楽しみです。

 

続いて、別な視点でライブラリを考えてみます。ライブラリ化する機能の種類で考えると、ライブラリ化のゴールが見えやすくなります。

真っ先に作ったのは、どのアプリでも必ず使う機能でした。UI部品の生成、日付と時間、ファイルの閲覧、電子メールの送信、描画機能などです。それらが作り終わると、環境設定など、どのアプリでも作りそうな機能をライブラリ化しました。こうした種類のライブラリ化は今も続けていて、ライブラリによるサポート範囲をさらに広げようとしています。

アプリ独自の要素として作らなければならない機能は、扱うデータを操作するモデルクラス、それを画面に表示して操作するビューとコントローラのクラスでしょう。作る量が大きい順に並べると、ビュー、モデル、コントローラとなります。

このうち、モデルのクラスは、すでにライブラリ化を進めています。まだ種類は少ないですが、少しずつ種類を増やして、ライブラリで済ませる率を向上させる予定です。

ビューは、モデルのように、個々のモデル全体をライブラリで作る形が難しい分野です。ビューの一部をライブラリとして用意し、それらを組み合わせて1つのビューを実現します。つまり、部品として作るのが適している分野です。ただし、機能の種類が多くあるため、ライブラリでカバーできる比率は、なかなか上がらないでしょう。

当面の方向性としては、次のように考えています。ビューを実現するための要素を、幾つかのタイプに分類して、タイプごとにライブラリを増やすつもりです。今までは、部品となる小さなビューだけでした。しかし、モーダルビューのように、動きの実現がメインとなるライブラリも、今後は増えていくでしょう。また、ビュー上にUI部品を繰り返して並べるような機能も、ライブラリとして作りました。これなどは、配置機能に特化したライブラリです。さらには、いろいろなUI部品を生成する関数群、同じUI部品を一気に生成する関数群など、ビューの構成部品の生成もライブラリ化しています。

あと、紹介していませんが、環境設定の専用ビューもライブラリを試作しました。以前に紹介した、環境設定の機能をライブラリ化したものと連動して、環境設定の値を変更するためのビューを生成します。凝った機能には対応できないレベルですが、一般的な設定の範囲であれば、もう使える状態です。以前紹介した環境設定のライブラリを使うと、環境設定の値を定義するだけで、環境設定の機能が作れます。ビューも同様で、環境設定画面の定義を用意するだけで、環境設定を変更するビューが作れてしまいます。これら2つは連動するので、環境設定機能とビュー機能のやり取りは、コーディングする必要がありません。このように、特定の機能を実現するビューなら、ライブラリとして、まだまだ作れる範囲があると思います。

 

アプリ全体として見た場合、ライブラリが適用できなくて、そのアプリ専用にコーディングが必要となる領域は、ビュー関係に一番多く含まれます。つまり、ライブラリ化の一番の肝は、ビューに関する機能のライブラリ化をどれだけ実現できるかです。モデルに関しては、5種類ほど作れれば、半分以上のモデルをライブラリで作れるでしょう。ビューでは、そのような考え方が通用しません。どんな切り口でライブラリ化したら良いのか、どうすれば新しい工夫ができるかが、ビューに関するライブラリ化の度合いを決めます。

今後は、さらにレベルアップできないか検討中です。もう少し違った切り分け方で、ビューの機能を実現できないかと、かなり考えています。まだ結論は出ていないものの、もしかすれば何とかなりそうなヒントだけは思い浮かびました。これを発展させて、新しい種類のライブラリが作れたら、ビューに含まれる機能のライブラリ比率が、かなり向上させられそうです。

 

アプリとして作る機能のうち、モデルとビューでのライブラリ比率が向上できると、アプリ全体でのライブラリ化率がかなり向上できます。

ライブラリなしで開発したときのコード量を10割としたとき、ライブラリの使用により何割減らせるかが、ライブラリの効果を評価する際の数値になると考えています。ライブラリなしで開発したときのコード量というのも、やや大雑把ですね。あえて説明すると、すべての機能をベタで書いたとき(雑誌やウェブでのサンプルのようなコード)のコード量という意味です。

Swiftのライブラリ化を始めた頃は、どの程度まで作れるのか予想が付きませんでした。漠然とですが、遠い将来は5割が目標だけど、当面は3割ぐらいかなと考えていました。

ところが、ライブラリが増えるごとに、それもライブラリの対象範囲が広がるとともに、5割は簡単に実現できると思うようになりました。実際、今まで作ったライブラリの機能だけに限定したアプリを作るなら、5割ぐらいはライブラリで済ませられ、残りの5割をコーディングする形になりそうです。

もし新しい機能を使うアプリを開発する場合は、その新しい機能の部分も、ライブラリとして作ります。そうすると、ライブラリが対応できる機能が増え、似たようなアプリを再び開発する場合は、やはり5割ぐらいがライブラリで対応できる状態になります。

今では、将来的に7割ぐらいも可能じゃないのかと、思い始めています。前述のビュー機能のライブラリ化が、どこまで実現できるかにかかっています。ただし、ライブラリがいくら充実しても、7割強ぐらいが限界ではないかと思います。ライブラリとして作りにくい機能が、ある程度は残りますから。

 

以上の話は、コード量に関してだけです。アプリ開発では、コードを作る以外の作業が多く含まれます。それが減らない限り、開発の負荷は大幅に減りません。その部分に関しては、かなり難しいでしょう。

それとは別に、開発スタイルが大きく変わる可能性はあります。新規に作らなければならないコードの開発量が減ると、とりあえず試しては変更し、異なる仕様を何度も試せます。ライブラリで実現した機能は、使う際の定義データや使い方を変更するだけで、ある程度まで機能を変えられます。もし機能が不足する場合は、ライブラリを拡張して、新しい機能を追加するでしょう。どちらにしても、いろいろと変えながら試せる可能性は、今よりもずっと高まります。

このような開発スタイルが、ライブラリ化を進めている当面のゴールです。それを実現するために、ライブラリで作るコードの割合を7割ぐらいにするのが、別な視点での当面のゴールとなります。

ライブラリを使って作ったアプリは、俗に言うプロトタイプではありません。本番でも使える、実際に動くアプリです。本番用のアプリを、プロトタイプ的に作ろうというのが、ライブラリ化の本当の目的と言えるかもしれません。

 

今回は趣向を変えて、ライプラリが充実したときの状態を、当面のゴールという形で書いてみました。具体的なコードばかり見ていると、大きな目標を見失ったりします。せっかくですから、大きな目標を掲げて、それに向かって努力したほうが、良い結果が得られるでしょう。これを読んだのを良い機会にして、自分なりの当面のゴールを、考えてみてはいかがでしょうか。

2015年6月23日火曜日

共通モデルのライブラリ化を試作(全体検討編)

アプリを作る際には、扱う情報ごとにモデル(MVCのM)のクラスを用意して、アプリ内の構造をスッキリさせます。オブジェクト指向では一般的な考え方でしょう。

情報ごとにモデルを作るのですが、同じようなパターンの情報も意外に多くあります。それらを毎回作っても構わないのですが、もしライブラリ化できれば、クラスを毎回作らずに済むのでは、と考えるようになりました。

もちろん、ライブラリ用として用意するモデルクラスが、1つで済むとは考えていません。よく使いそうなモデルを選び、おそらく数種類のモデルをライブラリ化します。その結果、半分ぐらいのモデルクラスを作らなくて済むと予想しています。

というわけで、試しに作ってみました。予想外に苦労したので、その過程も含めて紹介します。

 

モデルクラスをライブラリ化と言っても、どんな感じなのか想像できない人もいると思います。そこで、大まかな姿を最初に紹介します。それが想像できないと、これからの話が意味不明に感じるかもしれませんので。

ライブラリ化するのですから、モデルクラスで扱うデータの種類は、それぞれのアプリで異なります。まずは基本的なデータ型である、Int、Float、Bool、Stringを考えます。アプリ側では、この中のどれをどんな組み合わせで使うのか、モデルクラスのインスタンス生成時に指定します。データベースのフィールド定義と似たようなものです。このような形で作ると、モデルごとに異なるデータ型の組み合わせに対応でき、より多くのモデルで利用できるように仕上げられます。

インスタンス生成でデータ型の定義が終わったら、どんどん使い始めます。モデルクラスに用意されたメソッドで、新しいデータを追加したり、前に追加したデータを取得したり、データの一部を更新したりします。つまり、データ型の組み合わせ設定を用意し、それでインスタンス生成した後は、ただ使うだけなのです。

ライブラリ化したクラスで、付加機能を最初から用意すれば、さらに使いやすくなります。たとえば、入力したデータをタブ区切りのテキストに変換してくれる機能を付けると、そのデータをアプリ側でコピーして、他のアプリ(表計算アプリなど)へ持っていけます。また、少し前に紹介したファイル保存の機能に対応させておけば、そのメソッドを呼び出すだけでファイルやネットへの保存もできます。わざわざ作る必要はありません。

おそらく一部のアプリでは、特別に追加したい機能も出てくるでしょう。その場合は、ライブラリ化したモデルクラスのサブクラスを作って、必要な機能を追加する方法が可能です。独自要望の多くは、この方法で何とかなると思います。

 

ライブラリ化すると良いことが多いものの、上手に作らないと、デメリットも生じます。その点も最初から考えておかなければなりません。

真っ先に思い浮かんだのが、データ型の検査です。複数のデータ型を自由に組み合わせる場合、AnyやAnyObjectなどの汎用データ型に入れて扱いたくなります。モデルクラス内だけでなく、getなどのメソッドでも汎用データ型を使うと、もう大変です。コンパイラのデータ型検査機能が無効になり、実行時エラーの続出といった悲惨な状況へ向かうかもしれません。できる限り汎用データ型を使わず、データ型検査機能を有効に働かせることが大事です。

と書きましたが、実際に作るとなると大変です。なにしろ、データ型を自由に組み合わせて使うわけですから、汎用データ型を使わずに作ると、組み合わせ数が膨大になりそうです。どうすれば良いのでしょう。

ライブラリ化する際には、ライブラリではない形で作るよりも多くのエラー検査機能を入れます。でもモデルクラスの場合、アクセスが多いことも考えられ、検査が多いと処理が遅くなってしまいます。どの程度の検査を入れるのか、注意深く決める必要があるでしょう。現実的には、検査内容は最低限だけに絞り、あまり入れない方向で進めると思います。

 

以上の点を踏まえた上で、いよいよ具体的なモデルクラスの話に移りましょう。

どんなモデルを最初に作るかは、決めてあります。もっとも簡単そうなモデルを選びました。記録カードを扱うようなモデルをです。

そのカードは記入内容が予め決められていて、用意された欄にどんどん記入し、カードが増えていくような感じです。言ってみれば、カード型データベースからデータベース機能を抜いたようなモデルでしょう。一般的には、記録カードと呼ばれるものです。

もう少し詳しく書きましょう。まず最初に、カードに記載する内容を決めます。何個の項目を含み、それぞれの項目のデータ型が何なのかを決めるわけです。それぞれの項目に名前も必要でしょう。

具体的には、次のような感じになります。ゲームなどのイベントで、参加者の得点を記録するカードの情報を考えます。会員番号はInt、氏名はString、得点はFloat、特別会員はBoolという感じです。これを参加した人の数だけ、カードへ毎回入力します。どんどん入力すると、参加人数と同じ数のカード情報が保存されます。

別な例として、アクセスログなんかも考えられます。日付はIntに変換、時刻もIntに変換、IPアドレスはStringに変換、アクセス種類はString、アクセス内容もString、エラー有無はBoolとかです。

たいていの情報は、4つの基本データ型に変換して保持できます。それ以外のクラス・インスタンスも扱えるようにするかは、4つのデータ型で作った後に検討することにしました。まずは、4つのデータ型で使えるように仕上げるのが先決です。

 

今回は、どんな内部構造で作ったら良いのか、まったく想像できませんでした。そのため、とりあえず作りながら考えることとしました。どんなメソッドが必要なのかとか、何も考えずに作り始めたわけです。

真っ先に検討したのが、クラス内でのデータの持ち方です。複数の項目があって、それぞれデータ型が異なります。また、どの項目なのか外部から指定できる必要もあるでしょう。項目番号で指定するのか、名前で指定するのか。

最初は、項目番号で指定することを考えました。いろいろなデータ型を入れるのですが、データ型を検査するためには、AnyやAnyObjectを使えません。そのデータ型の配列を用意するしかないでしょう。そして、用意した個々の配列を管理するための親配列も追加しました。親配列は[Any]で用意し、その要素にデータ型の配列([Int]や[String])を入れるという形です。

データ型の配列は追加などがあるので、Varで初期化します。昔のソースコードは決して残ってないので、肝心の部分だけ思い出しながら書くと、次のような感じだったと思います。なお、変数名は完全に忘れたのでデタラメです。

// 親配列に、データ型の配列を入れる(思い出しながら書いたので、一部が間違っているかも)
var cAryMain: [Any] = [Any]()
// 子配列を作って、親配列に入れる
var iAryInt: [Int] = [Int]()
var iAryFloat: [Float] = [Float]()
cAryMain.append(iAryInt)     // 最初の項目はInt型
cAryMain.append(iAryFloat)   // 2番目の項目はFloat型

ここまでは問題なく作れました。さっそく次のような形でデータを追加しようとしたところ(これも思い出しながら書いているので、一部が間違っているかもしれません)、appendの行がコンパイルエラーになりました。

// データ型の配列に要素を追加したいが、コンパイルエラーに(同じく、一部が間違っているかも)
let iInt: Int = 100
(cAryMain[0] as! [Int]).append(iInt)  // この行がエラーに

英語のエラーメッセージから推測すると、どうやら配列[Any]に入れてしまった配列[Int]では、appendなどが使えなくなるようです。間違った使い方を防止するために、安全装置的な検査が組み込まれているのでしょうか。これでは、まったく使い物になりません。

諦めきれないので、もう少し粘ってみました。もしかして、参照渡しでアクセスすると、コンパイルエラーが出ない可能性があるかなと。そこで、cAryOya[0]を関数の引数として渡し、inoutを指定してみました。残念ですが、結果は同じでした。

他にも、思い付いた方法で試してみたのですが、最終的にはコンパイルエラーが出てしまいます。やはり、どこかで安全装置が働いて、許してくれないのでしょう。変数[Int]を変数[Any]に入れる方法は、完全に諦めました。

ここまでの段階で、他のメソッドなども少し作っていました。中心となる構造が使用不可になったため、すべて最初からやり直しです。

 

気を取り直して、もっと確実な方法で作ることにしました。データを入れる配列[Int]や配列[Float]などは、配列[Any]に入れず、配列[Int]や配列[Float]のままで扱うことにしました。これが一番確実な方法ですから。

ただし、そのままだと何番目の項目がどこに入っているか不明なので、参照インデックスの役目を持つインデックス用配列[Int]を用意します。このインデックス用配列に、それぞれのデータ配列のインデックス番号を記録しておきます。これとは別にデータ型を示す配列変数も用意します。これら2つが管理用の配列で、両方の値を参照すれば、どのデータ型なのかと、どのデータ位置に保存されているのかが分かるというわけです。

具体的に仕上がったコードは、次のようになりました。

// 管理用の配列
var cAryType: [ZmType] = [ZmType]()  // 項目のデータ型の定義
var cAryDataIdx: [Int] = [Int]()     // データ配列内のインデックス番号
// データを入れる配列
var cAryDataInt: [[Int]] = [[Int]]()        // データ配列
var cAryDataFloat: [[Float]] = [[Float]]()
var cAryDataBool: [[Bool]] = [[Bool]]()
var cAryDataStr: [[String]] = [[String]]()

この中のZmTypeは、データ型を指定するために作った列挙型です。決められたデータ型しか指定できないようにするためです。

ここで、データ型の定義として「Int,Float,Int,String」が指定されたとします。するとcAryDataIdxには、[0, 0, 1, 0]の値が入ります。意味としては「Int型のインデックス0、Float型のインデックス0、Int型のインデックス1、String型のインデックス0」となります。データ型の定義にIntが2つ含まれるので、Intだけはインデックス0とインデックス1が作られたわけです。

4つのデータ型の配列は、どれも2次元で作りました。それぞれ複数の項目で使われる可能性があるからです。「Int型のインデックス0」で使うときは、cAryDataInt[0][0], cAryDataInt[0][1], cAryDataInt[0][2], ...とアクセスし、「Int型のインデックス1」で使うときは、cAryDataInt[1][0], cAryDataInt[1][1], cAryDataInt[1][2], ...とアクセスします。

どのデータ配列もデータ型が指定されているので、データ型が決まった形で使われます。また、すべてのメソッドを、データ型を指定した形で作ります。結果として、コンパイラがデータ型を検査できる形に仕上がりました。設計上の一番大事な点を、何とかクリアーできました。

 

キリが良さそうなので、ここで一旦区切ります。具体的なSwiftコードは、次回の投稿で紹介します。今回の内容は全体設計という形ではないため、「全体設計編」ではなく「全体検討編」としました。

 

(使用開発ツール:Xcode 6.3.2, SDK iOS 8.3)

2015年6月11日木曜日

ファイルの読み書きも間接参照で(作成理由編)

アプリで作成したデータを保存する場合、ファイルとして書き出すことが多いでしょう。作成データだけでなく、アプリの設定内容なども、ファイルとして保存することが多いはずです。

こうしたファイルに関する読み書きは、独自ライブラリとして用意し、それを使うことで、似たようなコードを何度も書かなくて済みます。ここまでなら、ライブラリ化が好きな人だと普通に行っているでしょう。

では、さらに1歩進めて設計するとしたら、どのような構造になるでしょうか。その辺の検討結果と、実際に作ったクラスを紹介ます。

 

まずアプリの一般的な構造を考えましょう。アプリの中心部分では、そのアプリに固有の情報を扱っていて、画面に表示したり、入力を求めたりします。入力されたデータや、外部から取得したデータを保存するとき、ファイルへ書き出すのが一般的です。

保存先としては、ファイル以外でも可能です。たとえば、ネット上のサーバーとか。つまりファイルとは、情報の保存先の1つでしかありません。

いくつかの中の1つである以上、切り替え可能なように作るのが良い作り方でしょう。保存先を単純に切り替えるだけでなく、同じ情報を複数に保存するとか、その片方への保存は1日に1回だけとか。切り替え可能な形で作っておくことで、保存する機能の拡張が格段にやりやすくなります。

つまり、アプリの内部構造として、中心部分の処理から、保存する処理を分離したいわけです。中心部分の処理では、どこに保存するのか、どんな名前で保存するのか、まったく知らない形となります。保存データを作った際には、保存する処理にデータを渡すだけで、あとは知らないという感じです。

 

以上のように考えた結果、ファイルの読み書きを間接参照で作ることにしました。ファイルの読み書きの基本的な部分は、すでにライブラリ化してあります。現状のアプリでは、それを直接呼び出しているのですが、今後は間接参照に変更しようということです。

間接参照をどのように作るのかが、一番重要です。大事な機能としては、保存先を切り替え可能に作る点があります。つまり、アプリの中心的な処理では、どこへ保存するのか知らなくても動くように作り、保存する処理が複数あって、それらが交換可能になるという形です。

そこで、間接参照を実現するためのリンククラスを用意することにしました。アプリ側では、このリンククラスのインスタンスを生成し、そのインスタンスへアクセスすることで、ファイルへの読み書きを実現します。具体的には、このリンククラスが、ファイルの読み書きのライブラリを呼び出して処理します。今まではアプリが、ファイル関連のライブラリを直接呼び出していましたが、改良版では、アプリがリンククラスを呼び出し、そのリンククラスがファイル関連のライブラリを呼び出します。また、どこへ保存するか、どんな名前で保存するかはリンククラスが持ち、アプリの中心処理では持たない形となります。

アプリがリンククラスのインスタンスを生成する際に、保存場所(ディレクトリ)とファイル名を指定します。そのため、ファイルとして保存するデータの数だけ、インスタンスを生成することになります。1つのファイル用に1つのインスタンスを生成するというルールです。

リンククラスで重要なのは、交換可能に作ることです。ネット経由での保存など、ファイル以外の保存先も考えられます。どの保存先でも共通のメソッドを持たせ、保存先が変更されても、ソースコードの変更を最小限に抑えます。

その実現で大事なのは、メソッド名と引数のデータ型です。これらが同じであれば、別なクラスに切り替えたとしても、修正箇所はたった2箇所だけになります。たとえば、変数名prefStorageで今回のリンククラスをインスタンス生成した場合、インスタンスへのアクセスは変数名prefStorageとメソッド名だけしか使いません。もしメソッド名が全部同じで、ネット上へ保存するリンククラスを別に用意したとき、次の2箇所だけ変更すれば良くなります。インスタンス生成するコードのリンククラス名を変更し、インスタンス生成で指定するする初期化の値(ディレクトリ位置やファイル名)を変えるだけです。それ以外のコードである、変数prefStorageへアクセスする箇所のコードは、変更しなくて済みます。このような形であれば、交換可能の良い実現方法でしょう。

以上のように考えると、ファイルの読み書きを強く意識したメソッド名(readやwrite)は適しません。もっと一般的なloadやsaveが、より適していると言えます。そこでリンククラスでは、メソッド名にloadとsaveを使うことにしました。

 

過去に作ったアプリを見ると、単純なloadとsaveだけでは不足です。デフォルト値を入れたファイルがあり、それを呼び出す機能も必要です。そこで、loadを2つ用意します。単純なloadと、デフォルト値のloadです。

以上を整理すると、次のようになります。とりあえず、ファイル編だけです。

リンククラスの主な仕様(ファイル編)
・保存先の情報を持つ:ディレクトリとファイル名
・初期化:保存先ディレクトリとファイル名を設定する
・保存メソッド:値を受け取ってファイルに保存する
・ロード・メソッド:保存されている値をロードする
・デフォルト値のロード・メソッド:デフォルト値をロードする

機能が少ないので、かなり単純なクラスになるでしょう。

 

さて、ここまでの話では、保存するデータの中身について触れていませんでした。保存データのデータ型が違うと、同じ処理を使えません。たとえば、ファイルから読み込む処理は、文字列、バイナリー、NSDictionary、NSArrayで違います。ファイルへ書き出す処理も同様です。つまり、扱うデータ型ごとに、別々なクラスを用意しないといけないわけです。

リンククラスの種類(ファイル編)
・文字列(文字コードはUTF-8)
・NSDictionary
・NSArray
・バイナリー

構造が簡単なクラスで、しかもファイルの読み書きライブラリが既に作成済みなので、作るのは簡単です。

それぞれのクラスでは、扱うデータの型が決められています。そのおかげで、コンパイラの型チェック機能が有効に働き、ちょっとした間違いなどをコンパイル時点で発見できるようになります。

 

リンククラスの作成理由を簡単に紹介するつもりでしたが、書いてみたら予想より長くなってしまいました。いつもの全体設計編というレベルではないので、作成理由編とし、ここで一旦区切ります。具体的なSwiftコードは、次の投稿にて。

2015年5月27日水曜日

ライブラリ等の命名ルールを再考

このブログで紹介しているように、いろいろなアプリで共通に使える機能を、少しずつ独自ライブラリ化しています。ライブラリの数が増えてきて、少し気になっていることがあります。今まではあまり考慮していなかった、命名ルールのことです。

今後もライブラリは増えるでしょうから、あとから区別しやすいように、クラス名などの命名ルールを考え直すことにしました。対象となるのは、ファイル名、クラス名、メソッド名、データ型名、変数名、定義値名などです。何と何を区別すべきなのか、どうしたら簡単に区別できるのか、いろいろと悩んで得た結論を紹介します。

 

まず最初は、何と何を区別するかです。普通に考えて出てくるのは、共通ライブラリとアプリ独自の区別でしょう。

でも良く考えると、ソースコードには他のものも含まれています。Swiftの予約語、iOSのAPIに含まれるクラス名やメソッド名、それ以外のライブラリなどです。これらを、自分が作ったもの(共通ライブラリとアプリ独自の両方)と区別したくなります。つまり、共通ライブラリ、アプリ独自の処理、その他の3つで区別するという結論になります。

この3つのうち、その他だけは、すでに名前が与えられています。自分で名前を変えることはできません。そうなると、共通ライブラリとアプリ独自処理の両方に命名ルールを決めて、その他と区別するのが現実的な方法でしょう。

 

命名ルールで区別する方法としては、参考になる前例がいくつかあります。もっとも有力なのは、名前の先頭に、共通の1文字または2文字を付ける方法です。iOS関連で挙げると、NSで始まる一連のクラス名でしょう。NSはNextStepの略で、iOSのもととなったNextStepのクラスから続いています。というわけで、私も同じように、先頭に共通の文字をつけて区別することにしました。

すでに使っているのは、zという文字です。共通ライブラリとして作ったクラスのインスタンスを入れる変数の一部では、先頭にzを付けています。日付関連ならzDate、ファイル関連ならzFilesと。zを選んだのは、zで始まる英語の言葉が少ないのが理由です。

区別するのは2つですから、文字がもう1つ必要です。いろいろ悩んだ結果、やはり言葉の数が少なそうなyを選びました。つまり、共通ライブラリにはzを、アプリ共通の処理にはyを使うということです。

 

具体的な文字が決まったので、命名ルールを順番に決めていきましょう。

 

まずはクラス名から。クラス名は大文字で始まるため、共通ライブラリでは、大文字のZを先頭に付けます。例えばPhotoSelectorなら、ZPhotoSelectorとするわけです。先頭のZの次も大文字にすることで、先頭のZが、名前とは違う特別な文字だと伝わりやすいでしょう。アプリ独自で使うクラスも同様に、先頭に大文字Yを付けます。

これらのクラスが混在すると、変数宣言でクラス名が現れたとき、先頭がZなら独自ライブラリのクラス、先頭がYならアプリ独自のクラス、その他はそれ以外のクラスと区別できます。それ以外にも先頭がZやYのものがあるので、絶対とは言えませんが、ほとんど問題にならないでしょう。

 

続いて、クラスのインスタンスを入れる変数名です。今まで、共通ライブラリでの変数名の一部には、先頭に小文字のzを付けていました。前述のzDateやzFilesです。この命名ルールのままで構わないので、これからも継続します。また、今まで付けていなかった変数名でも、先頭にzを付けるように変更します。

問題は、アプリ独自のクラスです。そのインスタンスを入れる変数名だけ、先頭に小文字のyを付けるのはどうでしょうか。たとえばyProductとか。確かに区別はできるものの、使いやすいかどうかは試してみないと分かりません。とりあえず試してみて、良かったら続け、さほど良くなかったら命名ルールなしに戻したいと思います。

 

続いて、メソッド名です。これは、クラスのインスタンスを入れた変数名と一緒に使います。その変数名が区別を含んでいるため、わざわざ区別を入れても、二重の情報になってしまいます。というわけで、特別な命名ルールは使いません。

 

今度は、enumなどに付けるデータ型の名前です。enumでデータ型を用意すると、決められた値しか入れられませんから、値のエラーチェックも不要になり、さらに読みやすさも向上したコードが作れます。大変便利で良く使っています。

今までは、あまり気にせずに名前を付けてきました。もしかしたら、似たような名前を作っているかも。また、これから作りそうな気もします。重複しないとともに、どこに所属しているのか明らかなほうが良いと考えました。所属する場所のほとんどは、それを使うクラスです。クラスとの関連性を示せたら良いでしょう。

そこで命名ルールは、クラス名の略号を数文字で表し、先頭に付けることにしました。その数文字ですが、最初の1文字だけが大文字で、それ以外は小文字にします。たとえば、ZPhotoSelectorクラスならZpsと略せ、それをデータ型の名前の先頭に付けます。もしデータ型の名前がZpsBtnTypeなら、ZPhotoSelectorクラスで使われている、ボタンのタイプを意味すると推測できます。Zで始まるため、ライブラリのクラスであることも分かります。

アプリ独自のクラスでも、同じ命名ルールを採用しましょう。Yで始まる数文字の略語を得て、データ型の先頭に付けます。

 

続いて、定義値の名前です。定義値というのは、最大値や固定値などに名前を付けて定義し、処理の外に出して、見つかりやすくするものです。後から変更しそうな値に適用します。C言語の時代から使われていて、すべて大文字で表現する名前がよく用いられます。

私の場合だけかもしれませんが、処理の外に出す目的以外でも使っています。共通で使うような値を、定義値として最初に用意し、アプリ全体で使ったりします。定義値を用意することで、名前による間接参照にもなりますし。

このような使い方なので、使う機会はかなり多いです。作った場所というか、持ち主が区別できると良いと思っています。

その命名ルールですが、ライブラリの場合は、先頭にZ_を付けることにしました。名前の全部が大文字なので、Zだけだと区切りが不明確になるからです。今までCOLOR_ERRORとしていたのを、今後はZ_COLOR_ERRORとします。

もう1つとなるアプリ独自の定義値の名前は、何も付けないことにしました。その他の分類で似たような定義値が使われていないようなので、ライブラリだけ区別すれば十分と考えたからです。先頭にZ_が付いていればライブラリの定義値、それ以外はアプリ独自の定義値と判断します。

 

最後は、ソースコードのファイル名です。これは以前に「管理しやすい分類情報付きファイル名を使おう」にて紹介しました。あれから分類が1つ増えたので、今では次のようになっています。

// ファイル名の先頭に付ける主な分類情報
・AC:特定の条件(装置など)に依存する共通ライブラリのクラス(複数アプリで利用)
・BP:共通ライブラリの関数や定義値など(複数アプリで利用)
・BV:共通ライブラリのクラスでUIView型(複数アプリで利用)
・BC:共通ライブラリのクラスでUIView型以外(複数アプリで利用)
・MC:アプリで使うモデルのクラス
・VC:アプリで使うビューのクラス

このような形でファイル名を付けると、ファイルの数が増えても大まかに分類できます。最初の2文字が大分類、その次の言葉が中分類、さらに次の言葉が小分類という形で、それぞれの役割が簡単に推測できてしまいます。非常に便利に使っているので、今のままの命名ルールで続けます。

 

今回の考察によって、ライブラリとアプリ独自のコードが、かなり区別できるようになるはずです。ライブラリ内の名前の変更が必要ですが、後になるほど大変なので、今やっておくしかないでしょう。少しずつ更新しようと思います。

もう1つ、作らなければならないものがあります。上記のルールを書いた書類を用意して、ライブラリを使っているアプリにも入れることです。そうしておくと、私以外の人がアプリをメンテするとき、ソースコードを解読しやすくなるでしょう。私が永遠にメンテできるはずはないので、次の人への準備は非常に重要だと思います。

アプリをビルドしたとき、余計な書類が含まれていてもアレなので、ルールを書いた書類はSwiftのソースコードが良いかもしれませんね。すべてをコメントとして書き、ファイル名にZZ_to_Developerとか付けて。メンテする人が、必ず見てくれるように。

 

さっそく、今作成中のライブラリから適用しています。これまでのライブラリやアプリも、バージョンアップの際に更新する予定です。

2015年5月18日月曜日

ライブラリ化とInterface Builder不使用の重大な関係

先日の連休中に、友人のIT技術者と、じっくり話をしながら飲みました。そのときに、ライブラリ化の話で盛り上がったのですが、私が気付いてなかった点を指摘されました。その話を短かく取り上げます。

 

友人の指摘は「ライブラリ化が容易になっているのは、Interface Builderを使わずに開発していることが、非常に大きい」というものでした。ぜんぜん気にしていない点だっただけに、かなり驚きました。

友人の意見は大事な点が何個も含まれていましたが、要旨を整理すると以下のようになります。

友人の意見の要旨
・Interface Builderを使わないことで、
 ・ライブラリに含まれるのはSwiftのソースコードだけ
 ・サイズの変更が容易となり、Viewの大きさに合わせたサイズ調整が容易
 ・必要な数だけのUI部品が、短いソースコードだけで連続して生成できる

この中で一番大きな点は、Swiftのソースコードだけでライブラリが作れる点だというのです。

 

このブログの最初に宣言したとおり、私の開発ではInterface BuilderとStoryboardをまったく使っていません。UI部品の生成関数を用意して、すべてのUI部品をその関数で生成しています。そのため、ライブラリに含まれるのは、Swiftのソースコードだけとなります。まさに、指摘されたとおりです。

どのライブラリも、Swiftのソースコードだけで作られていて、しかも1つのファイルに収まっているため、アプリへは簡単にコピーして持っていけます。

当然ですが、アプリ内でのライブラリのバージョンアップも簡単です。古いソースコードを削除して、新しいソースコードに入れ替えるだけです。ライブラリのインターフェースはめったに変えませんから、アプリ側を直さずにバージョンアップできています。Swift側やAPI側の仕様変更を除いて。

 

ライブラリを作るときだけでなく、テスト環境まで保存しているiOS実験専用アプリ自体も含めて、Interface BuilderやStoryboardを使っていません。Xcodeの新規プロジェクトから、Single View Applicationを選び、空の画面のアプリケーションを用意しました。そのままSwiftコードだけを追加して、iOS実験専用アプリを仕上げています。

当然ですが、ライブラリのテストで使う画像や音のファイルは、iOS実験専用アプリのプロジェクトに追加しています。それ以外のテキストデータなどは、Swiftのテストコードに中に入れ、ソースコードの形で用意できるようにしています。テスト用のテキストファイルも基本的に、Swiftのソースコードから生成し、わざわざファイルを用意しないのが基本です。

このように、改めて見直すと、できる限りSwiftのソースコードから作っていますね。今書いていて気付いたのですが、別に用意している画像ファイルも、描画機能を使って描いてからファイルに保存すれば、Swiftのソースコードから作れますね。まあ、やらないでしょうけど。

 

Swiftでアプリ開発を始めるとき、ツールによる余計なトラブルを避ける理由と、自由度を優先するという理由から、Interface BuilderやStoryboardを使わないと決めました。その選択が結果として、ライブラリ構築の自由度も上げていたわけです。

自分にとっては、あまりに当たり前の選択だっただけに気にしておらず、言われるまで気付きませんでした。結果としては、Interface BuilderとStoryboardを使わない選択が、ライブラリ構築にも良かったわけです。

ちなみに友人も、Interface BuilderやStoryboardを使わない方式に切り替えたそうです。そして、自分専用の独自ライブラリを少しずつ構築中だとか。

 

とは言うものの、Interface BuilderやStoryboardを使わない開発を、他の人に勧めるかといえばノーですね。開発者にもいろいろな人がいて、便利ツールがないと苦労する人もいますから。ですから最初は、とりあえずInterface Builderを試すように勧めます。

Interface Builderを使わずに開発する方法には、軽い壁があると思います。それほど大きな壁ではありませんが、それを乗り越えられる人でないと難しいでしょう。具体的には、UI部品を生成するライブラリを自分で整えるとか、Interface Builderの代わりとなる道具を自分で用意する手間と技術が必要となります。その条件を軽く乗り越えられる人なら、Interface Builderを使わなくても大丈夫です。

もし大丈夫な人なら、使わないほうを積極的に勧めます。ライブラリさえ用意してしまえば、開発の自由度が格段に増し、すべてソースコードでコントロールできる形になりますから。経験が長いというか、それなりに実力のある人には、使わないほうを積極的に勧めたいですね。

 

Interface Builderを使わない開発では、画面レイアウトの問題が常に生じます(使う開発でもある程度は生じていますが、自動レイアウトで何とかなる場合もありますから、問題が軽減されているでしょう)。

今のところiPad開発ばかりなので、画面サイズの違いを考慮しなくて済んでいます。UI部品の表示位置や大きさを数値で指定する方法で、問題はまったくありません。しかし今後はiPadも、複数の画面サイズを意識しなければならない状況になると予想します。現状のiPhoneのように。

一応、対策は考えています。自動レイアウトは使いたくないので、画面サイズごとにレイアウトを切り替える予定です。切り替えといっても、ソースコードは1つにして、画面サイズごとに別な座標数値を使う方法です。座標数値を配列に入れ、その配列を参照しながら表示位置を決めれば、複数のレイアウトへ簡単に対応できます。UIView型ライブラリがサイズ可変なのも、このような状況を予想してのことです。配列から座標を読み込む方法で作った結果、見栄えや使い勝手が悪い場合にだけ、完全に別なレイアウトで作る予定です。

複数の画面レイアウトの問題は、Interface Builderで解決できるものではありません。自動レイアウトも限界はありますし、細かな見栄えは低下しがちです。今後も、大きな課題として残り続けるでしょう。

 

画面レイアウトの問題があっても、Interface BuilderとStoryboardを使わない開発を、止める気はありません。今までどおり、Swiftのソースコードだけで作った独自ライブラリを、どんどんと増やしていくつもりです。

Swiftでの開発に慣れてきて、Interface Builderを使っている方は、使わない方法を一度検討してみてはいかがでしょう。もしかしたらですが、素晴らしい未来が待っているかもしれません。最初の取り掛かりとして、UI部品を生成するライブラリ作りからお勧めしたいですね。

2015年5月15日金曜日

フォトアルバムから画像取得のライブラリ化を試作(将来の仕上げ編)

フォトライブラリから画像取得の独自ライブラリを試作した話の補足です。試作したソースコードを、最後に仕上げるときの考慮点について少し書きます。

 

当ブログの投稿に何度も書きましたが、ライブラリ化する際に大事な考慮点があります。複数のアプリで使えることに加え、似たような機能と交換可能に作ることです。将来の仕上げでは、それらの点も考慮しなければなりません。

複数アプリで使える点は、独立したクラスとして作ったことで実現しました。似たような機能と交換可能な点は、現状よりも深く考えて決める必要があるでしょう。

 

まず、似たような機能を考えてみます。やはり写真を取得する機能でしょう。真っ先に思い浮かんだのが、フォトライブラリ以外から取得する機能です。iPad内からの取得だけでなく、インターネット経由で取得する機能も考えられます。これらの機能に変えたり、切り替えて使う状況も考慮しておくのがベストです。

今回試作したクラスは、UIViewのサブクラスとして作りました。画面に表示する機能も含まれているため、画面上の操作や反応もクラス内で記述し、その部分はアプリと無関係に作れるので、アプリからの独立性が高いと言えます。そのため試作クラス側では、アプリを気にせずに、表示内容や操作方法の変更が可能です。

逆にアプリに関係する点は、最低限の内容になっています。画面に表示するサイズ、画像を選択中かの問い合わせ、画像の取得ぐらいです。このような形なので、別な機能と交換するのも容易になっています。

そもそも私がライブラリ化する際には、画面に表示して操作する機能の場合、UIViewのサブクラスを選択しています。その最大の理由は、ライブラリ化した側に表示や操作を作れるからなのです。もう1つ、表示サイズを可変にしているのも、交換しやすいようにと考えてのことです。今回の試作クラスも同じ方法を選んだため、予想どおり結果になったというわけです。

 

というわけで、似た機能との交換可能性を上げるためには、メソッドを整えるのがキモとなります。順番に見ていきましょう。

初期化では、画面上の表示サイズを指定しているだけですから、問題ありません。もちろん最小サイズの違いはありますが、大きく使う分には同じに使えます。もし小さいサイズで使う場合は、画面上のレイアウトで対応するしかないでしょう。

取得画像のデフォルトサイズ設定メソッドでは、縦横の大きさを指定しています。この大きさの意味、つまり指定した大きさの値が、どのように使われるのかは、交換可能な機能を実現するためのAPIに依存します。できれば最大サイズを指定しているという意味にしたいのですが、それが可能とは限りません。仕方がないので、最大サイズに近い画像を得られるように、それぞれの実現方法で工夫するしかないでしょう。

最大サイズ以外の指定方法を考えてみても、代わりとなる値の種類は思い付きませんでした。現実的な選択肢としては、現状のサイズ指定がベストだと思います。

続いて、画像の取得メソッドは2種類を用意しています。デフォルトのサイズ設定で画像を取得するメソッドは、そのままで構わないでしょう。もう1つのサイズ指定による画像取得メソッドも、サイズ指定の方法が現状でベストとなれば、こちらも同じで構わないはずです。

取得が失敗した際にnilを返す方法も、そのまま別なクラスで使えます。ただし、失敗した理由をユーザーに伝える方法は、何かしら用意しなければなりません。クラス内にUIViewを持ってますから、メッセージ欄に表示するのが現実的だと思います。

取得関係では他に、画像情報を取得するメソッドも試作クラスで作りました。これはPhotosフレームワークに依存するデータ型なので、似た機能と交換可能にはなりません。また画像情報からUIImageを得る変換メソッドも同様です。これら2つのメソッドは、今回の試作クラス独自の拡張機能という位置付けにして、可能な限り使わない方針に決めます。特別な理由がない限り使わないメソッドという扱いです。

最後は、画像が選択中かどうか問い合わせるメソッドです。こちらは、Bool型で返す形式なので、何も問題はないでしょう。

 

以上は試作クラスで用意したメソッドですが、他に必要となる共通メソッドはないか、そもそもメソッドを考える前に、他に必要な共通機能があるかも検討しなければなりません。

おそらく必要な機能としては、交換可能な似たクラスの内容により、それぞれで出てくると予想します。たとえば、インターネット経由で画像を取得するクラスなら、通信状況を表示する機能が必要でしょう。ただし、共通の機能ではないため、今回の検討からは外れます。

交換可能なクラスで共通する機能となると、残念ながら思い付きませんでした。とりあえずは、現状のままで構わないと判断しました。

 

今回のような検討(似たような別機能への交換可能性を考慮して作る検討)は、試作している途中のどこかで必ず行います。

使用するAPIの仕様が十分に見えていて、どのように作るのかが見通せる場合は、最初の全体設計の段階で検討できます。できるだけ早めに、検討したほうが良いでしょう。

しかし、初めて使用するAPIの場合は、詳細を知らない段階なので、検討しても後から変更する可能性が高まります。試しに作りながら、APIの仕様が大まかに見えてきた段階で、検討するのが効率的です。

実際には、中心となるメソッドを決める場合に、できるだけ汎用的な形式を選ぶようにしています。また、UIViewのサブクラスで作るなど、アプリから独立した形になる工夫も採用しています。そのため、メソッドの選択を大きく間違うことはありません。

全体として、気付いたら修正するという流れで構わないと思います。

 

似た機能と交換可能に作るという考え方は、変更への柔軟性を高めるための重要な点だと思います。ここで紹介したような検討を、作る際に試してみてはいかがでしょう。

2015年4月6日月曜日

SwiftとiOSの変化を意識したアプリ開発

今回は、いつもと趣向を変えて、違う話題を取り上げてみます。SwiftやiOS APIの将来について、開発ツール選びや開発方針との関連も含めて、ちょっと考えてみたいと思います。

 

開発ツールやAPIを選ぶことは、開発者にとって大事な選択です。とくに大きなソフトを作る場合、開発ツールやAPIの将来性を適切に見極めないと、時間をかけて開発したものが無駄になったりします。同様に、小さなソフトでも数が増えると、大きなソフトを作ったと同じ状況に陥ります。

見極めが大事だと書きましたが、開発ツール全体の傾向としては、少しずつ不安定な方向に変化していると感じています。昔のように、1つの言語をマスターすれば、安心して長い間使えるという時代ではなくなっていると感じます。上手に対応するためには、複数の言語やAPIを使えなければならない時代なのでしょう。見極めと同時に、どれか1つだけに固執しないのも、これからの時代は大事なのかもしれません。

 

で、肝心のSwiftとiOS APIの話です。これらも将来の変化を意識する必要があるでしょう。まずはSwiftから。

今のところSwiftは、アップルの開発ツールとして大きな地位を築きつつあります。築きつつというより、固めつつあると表現したほうが適切かもしれません。その流れを作っているのは、当然ながらアップルの方針です。

おそらくアップルは、開発用のプログラミング言語を、Objective-CからSwiftに移行したいのでしょう。現状では、Objective-Cを完全に無くすことはできませんから、段階的に移行する過程だと思います。今後の大きな流れとしては、Swiftの仕様を少しずつ拡張しながら成長させて、Objective-Cから完全に置き換える方向に向かっているのでしょう。

 

続いて、iOSのAPIです。現状のAPIは、OSXのAPIをできるだけ流用しつつ、座標などを少し変えて手直ししたものです。細かなクラスなどは、iOSとOSXで共通のものが多くあります。それは当然の選択で、あえて同じに作ることで、ソースコードを流用しやすくしています。

では、今後も今のAPIを使い続けるのでしょうか。有名な噂サイトに登場した噂話によると、どうやら新しいAPIを作っているようなのです。おそらくは、iOSとOSXで完全に共通のAPIとして作っているでしょう。iOSとOSXは、UIも少しずつ近づけていますから、これも当然の流れだと思います。

 

その新しい共通APIは、どのような形になるのでしょうか。当然の流れとして考えられるのは、Swiftとの親和性を強めることです。

現状のSwiftでは、iOS APIとの親和性が十分ではありません。たとえば、Dictionaryなら、NSObject以下のクラスを自由に扱えるのはNSDictionaryであって、SwiftのDictionaryではありません。同様にAnyも、NSObject以下のクラスとの親和性がAnyObject(中身はObjective-Cのid)に劣ります。

これらの欠点を解消し、SwiftのDictionaryやAnyとの親和性の高いAPIになるはずです。それ以外の面も含めて、Swiftとの親和性を第一に考えて設計されたAPIとなるでしょう。

その新しい共通APIは、Objective-Cからも使えるでしょうか。そのときになってみないと分かりませんが、アップルのことですから、使えなくすることも十分に考えられます。Swiftへの移行を強く進めるために。

 

おそらくは、APIの共通化だけが目的ではないでしょう。もっと現代的な設計に作り変えているのではないかと、予想します。

私だけの印象かもしれませんが、NSObjectをトップに持つ一連のクラスは、昔ながらのオブジェクト指向を強く意識した形で作られているように見えます。デリゲートなどの作り方に癖があるというか、全体的に美しくありません。また、使いやすくないことも大きな欠点だと思います。

アップルがどのような形に改良するかは不明ですが、おそらくは癖をあまり出さないで、ソースコードが書きやすい形でまとめ上げると予想してます。

 

つまり全体の流れとしては、プログラミング言語はObjective-CからSwiftに、APIはiOS/OSXの2つのAPIから共通モダンAPIに、という形になると予想します。当分の間は、それぞれの古いもの(Objective-Cと、iOS/OSXの2つのAPI)もサポートされるでしょうが、iOSやOSXのバージョンがどんどん上がるうちに、サポートしなくなる可能性が高いでしょう。

もう1つ、iOSとOSXという2つのOSの存在も、今とは違ってくるでしょう。おそらく、これも共通になり、1つのOSに統合されるはずです。UIが少しずつ近づいているわけですから、共通化も少しずつ容易になっていきます。もちろん現実は逆で、共通化する目的のためにUIを近づけているのでしょう。

アップル独自のチップであるAシリーズも、世代が進むごとに処理能力が向上しています。あと数世代も進めば、現状のパソコン用CPUと同等か、それ以上の処理能力を得られるでしょう。そうなったときが、共通OSへの移行に適した時期ではないでしょうか。

共通OSになったとき、iPhone、iPad、Macというハードウェアの区別に、あまり意味はありません。iPhoneの画面の大きな機種に、Xcode後継ツールをインストールして、無線キーボードと組み合わせながら、iPhone上でアプリ開発も十分に可能でしょう。実際に使うかどうかは別として。

 

以上のような流れですが、大きくは外れないと思います。大事なのは、プログラミング言語はObjective-CからSwiftに、APIはiOS/OSXの2つのAPIから共通モダンAPIに、という流れです。

いろいろな開発者がいますから「流れなんて考えず、また作り直せばいいよ」と思う人もいるでしょう。でも、作り直すのは大変です。誰にも頼めないユーザーもいるでしょう。作り直しだと余計に手間や費用がかかり、そこまでの費用を出せないユーザーもいるでしょう。どう考えても、できる限り最小限の手間で、使い続けられることが一番良いのです。

将来の手間を最小限にするためには、現時点でどんな選択をすれば良いのでしょうか。Xcodeを使ったiPadアプリ開発に限って考えると、次のような点が大事だと思います。

まずは、プログラミング言語の選択です。可能な限りSwiftで書くことは必須です。もしObjective-Cしか作れない機能があったとしても、全体をObjective-Cで作るのはお勧めできません。作れない部分だけ切り分けてObjective-Cで書き、残りの部分をSwiftで書くのがベストです。

APIに関しては、新しい共通APIが登場していませんから、現状のAPIを使うしかありません。でも、将来への対処方法が、まったく無いわけではありません。どのアプリでも共通で使う機能は、できるだけライブラリとして作り、すべてのアプリで共通して使えるように作っておきます。将来、新しいAPIが登場したとき、個々のライブラリを新APIで作り直して、入れ替えることを可能にしておきます。

共通ライブラリを使ったアプリに仕上げることで、入れ替え用の互換ライブラリを1つ作るだけで、どのアプリにもそのまま利用できます。ライブラリとして作るわけですから、テストも試験専用アプリで徹底的に行えます。アプリ側の細かくテストする必要はありません。徹底的にバグを消してから、アプリ側を入れ替える手順が可能です。

いくつものライブラリとして作っているので、1つずつ順番に新APIで作り直すことができます。それぞれのライブラリは関連する機能が集まっているので、新APIの仕様を調べるのも効率的でしょう。同様に、細かなテストも作りやすいはずです。

ライブラリ化の大きなメリットは、ライブラリ化してないアプリを新APIに移行する作用を想像すると、よく分かります。ライブラリ化してないのですから、すべてのソースコードが、それぞれのアプリで異なります。新APIに書き換えるときは、アプリごとに細かく見ながらソースコードを書き直していきます。テストも個々のアプリごとに、別々に行う必要があり、非常に大変な手間となるでしょう。

当然ですが、共通ライブラリ化の一番のメリットは、将来への備えではありません。共通化することで、新しいアプリを作るときの手間を大きく減らせることが、最大のメリットです。さらには、ライブラリにバグが見つかったとき、バグを修正すれば、すべてのアプリで入れ替えが容易です。アプリごとに個別に直す必要はありません。こうしたメリットに加えて、将来への備えにもなるのですから、やはり非常に大きなメリットと言えるでしょう。

 

長くなりましたが、ここまでの話をまとめると次のようになります。

現状のiPadアプリ開発で重視したい点
・できるだけSwiftで作る(Objective-Cでなければ作れない箇所は、その部分だけObjective-Cで作る)
・どのアプリでも共通に使う機能は、関連する機能を集めてライブラリ化して、取り替え可能に作る

以上は、あくまで私個人の考察結果です。信じるのも自由、一部だけ信じるのも自由、まったく信じないのも自由です。どちらにしても、将来起こる変化を少しは気にして、アプリ開発の方法を考えてみてはいかがでしょう。

2015年3月17日火曜日

Optional型の使い方(改めて考えてみた)

Swiftの特徴の1つに、Optional型があります。どのような役割なのか、どのように動作するのかは、多くの詳しい人がブログなどで書いていますから、ここで改めて書く必要はないでしょう。

でも、どのように使うのが良いのかは、あまり深く考察されてないように感じています。それなのに、いろいろと悩む点が多いのではないでしょうか。私自身も、まだ悩み続けています。Swiftを最初に使い始めた頃に比べると、使い方が少しずつ変化してきてます。Swiftにも少しずつ慣れてきたところなので、Optional型の使い方を改めて考えてみました。じっくりと改めて考えることで、使い方の整理ができて、今後のプログラミングに役立つのではないかと思うからです。

なお、Optional型のような機能の使い方は、各人のプログラミング方針に大きく影響を受けやすいものでもあります。このような考え方もあるのかという意識で読んでください。ちなみに私は、Swiftの変数宣言で、データ型の指定を積極的に付ける方針でプログラミングするタイプ(コンパイラのチェック機能を積極的に利用して、実行前に間違いを見付ける派)であり、またInterface BuilderやStoryboardを使わない派でもあり、世間的には少数派だと認識しています。

 

正直なところ、最初のうちは深く考えずにOptional型を使っていました。APIでOptional型が返る場合は、そのままOptional型で受けたり、アンパックしてOptionalを外したり、その場その場で決めていました。明確な判断基準は持たず、何となく決めていたという感じです。

自分が作る関数でも、戻り値にnilが入る場合には、深く考えずにOptional型を使っていました。あまり疑問は持たず、そうするのが当たり前だと思っていました。

新しい言語やAPIを使い始めた当初は、細かい部分にまで気を回す余裕がないので、当然と言えば当然のことでしょう。

 

では、Swiftに慣れてきた現時点で改めて考えると、どのような使用基準が良いのでしょうか。一番大事な基準は、やっぱり「Optional型を、できるだけ使わない」でしょう。使い方の話なのに、いきなり「使わない」という基準が登場します。でも、それが極めて大事なことですから、やはり一番気にしなければなりません。

Optional型の変数では、指定された型の値ではなく、nilが入っている可能性があります。つまり、nilが入っている場合も常に考慮しながらプログラミングする必要が生じるのです。nilが入っていないか検査するとか、必要に応じて余計な処理を作らなければなりません。

とくに大変なのが、時間が経過してからメンテする場合でしょう。全体の構造から細かな機能まで、何もかも忘れてしまっています。もし一部の機能だけ修正が必要になったとき、そこにOptional型の変数が含まれていたら、nilの検査を入れるべきか判断するために、関係するソースコードを広く見なければなりません。もし面倒に感じたなら、nilの検査を一応入れておき、nilならエラーメッセージを出すといった、小手先の対処方法を考えるかもしれません。

ですから、Optional型の変数を使うのは、nilが入っている可能性がある狭い範囲に限定し、途中でnilが入ってないと判断できたら、Optional型の変数を使うのを止めて、Optional型でない変数に切り替えるのがベストな方法だと思います。

 

Optional型を使わないようにしようと思っても、使わなければならない場面はいくつもあります。その場面ごとに、できるだけ使わない方法を考えてみました。

 

Optional型が必須となる状況として真っ先に挙げられるのは、APIから受け取る値です。種類が多いのも特徴で、インスタンス生成が失敗したとき、nilを返すような仕様になっています。こうした値にOptional型が指定されていれば、Optional型の変数を使わなければなりません。

ただしSwiftには、このような状況を上手に記述できるようにと、if let文が用意されています。Optional型の変数で受け取るのではなく、Optional型でない変数で受け取るように記述できます。また、nilを受け取ったときの処理(非正常時の処理)も、一緒に記述できます。

// APIから得た値を、 Optional型でない変数で受け取る
...
// Optional型の値を受け取る
if let iNSDic: NSDictionary = NSDictionary(contentsOfFile:iPathFile) {
    // 正常時の処理
    ...
} else {
    // 非正常時の処理
    println("ERROR:ReadPlist")
    return
}
...

このような作り方すれば、Optional型の変数を使わなくて済みます。

逆に、if let文を使えない状況のときは、いったんOptional型の変数で受け取って、必要なところだけOptional型の変数を使うような作り方になります。その場合も、Optional型の変数をできるだけ使わないように作ります。

 

次は、UI部品などを入れる変数です。複数の箇所から参照されるUI部品は、変数名を付けて宣言します。最初の状態では空で、初期か処理の中でインスタンス生成するという流れになります。

理想的には、変数宣言した箇所でインスタンス生成するのが一番です。しかし、そのように作れないことも多くあります。関連するUI部品の変数宣言は並べておきたいし、初期化処理はまとめて別な場所に入れたいなど、それなりの理由があるからです。結果として、変数宣言とインスタンス生成が離れてしまいがちです。

このような場合には、「?」を付けた通常のOptional型ではなく、「!」を付けた特殊なOptional型(Implicitly Unwrapped optionals)の変数として宣言します。このタイプの変数は、変数の値を参照するとき、明示的にアンラップしなくて使える点です。Optional型でない変数のように扱えます。

// 宣言した後から初期化する変数は、「!」を付けた特殊なOptional型で作る

// 変数の宣言
var txfUserName: UITextField!

// まとめて初期化(インスタンス生成)の中に含める
...
txfUserName = createTxtFldF("12", 16, ALIGN_LEFT, 700, 460, 100, 30)
...

使う際の注意点としては、値を参照する前に、必ず初期化しなければならないことです。初期化する前に参照すると、実行時エラーとしてアプリが異常終了します。でも実際には、理解して使っている限り、初期化しないで参照するなんて起こりません。まれに初期か処理を付ける前に実行してしまったとかはありますが、異常終了したことで気付きます。この種のエラーは、きちんと作っている人にとって、心配してくて構わない部類のエラーと言えます。

 

Optional型の変数をアンラップする方法として、「?」と「!」の2種類が用意されています。違いは、変数の値がnilの場合の動作です。「?」ならnilが返り、「!」なら実行時エラーとなります。

通常の場合は、「!」で構わないと思います。アンラップして使う際には、nilではなく、インスタンスが入っている前提があります。それなのにnilが入っているというのは、プログラムまたはデータに問題がある証拠です。その場で実行時エラーを発生させたほうが、どの変数が悪かったのか明確になって調べやすいでしょう。

逆に「?」でアンラップするのは、nilが入っても構わない特殊な使い方です。該当する場合にだけ、「?」でのアンラップを使うことになります。

 

自分が作る関数やメソッドも、取り上げましょう。戻り値のある関数の場合、指定された型の戻り値を返せない状況が、どうしても発生します。その場合にnilを返して、呼び出し側にエラーだと伝えます。この形が、昔から(C言語などの時代から?)使われている一般的な方法でしょう。こうした考え方があり、その考えに沿ってAPIが作られているからこそ、Optional型が用意されていると言えます。

では、本当に仕方がないのでしょうか。自分が作る関数やメソッドでも、すべて同じ考え方で作って構わないのでしょうか。この点に、私は疑問を持ちました。そして、いろいろな状況を区別して考えました。その結果、本当に仕方がないときにだけnilを返し、それ以外はnil以外を返す形で作っても構わないのではないかと思い始めました。状況の違いを、具体的に示して説明しないと、何を言っているのか分からないと思いますので、いくつかの例を挙げてみます。

 

まず最初は、独自ライブラリの使い方を間違ったケースです。対象となる独自ライブラリのクラスは、UIViewを拡張したクラスで、UIViewの大きさ(幅と高さ)に最低値があります。その最低値よりも小さな値を指定して、インスタンス生成しようとした状況です。普通に考えると、指定値が間違ってますから、インスタンスは生成せず、nilを返す形の作り方になります。当然、戻り値はOptional型となります。

しかし、考え方を少し変えたらどうでしょう。最低値よりも小さな値を指定した場合は、エラーにせず、最低値に置き換えてインスタンス生成する仕様に変えたら。インスタンスが生成できるわけですから、nilを返す必要がなくなります。

ただし、そのままだとエラーに気付きません。目立つエラーメッセージをコンソールに表示して、気付いてもらいます。きっちりと開発したい人(私も該当します)なら、エラーメッセージを見逃さないで気付くはずです。

エラーを知らせるための、別な方法も考えられます。UIViewのように画面に表示するクラスなら、そのUIViewに付けてあるUILabelなどに、エラーメッセージを表示させるのも1つの手です。文字を赤くして目立たせるなども効果的でしょう。これなら、コンソールのメッセージを見なくても気付けます。

この例での考え方は、エラーにせずに救える場合は救ってあげて、nilを返さないというものです。救ってあげられる場合は限られていますから、適用は限定的でしょう。

 

似たようなケースとして、何かの値を文字列に変換する関数を考えます。変換対象のデータにエラーがあるとき、Stringの代わりにnilを返すことで、エラーを知らせるという仕様もアリでしょう。当然、戻り値はOptional型になります。

しかし、nilを返す代わりとして、エラーを意味する短い文字列(たとえば「ERROR!!!」とか)を返すとともに、コンソールにエラーメッセージを出す仕様も考えられます。こうすると、戻り値にOptional型を使わずに済みます。

データ型が文字列でなく数値の場合は、あり得ない値を返すことになります。整数なら-99999、浮動小数点なら-99999.9とかです。使用状況に応じて、あり得ない値を決める必要があるでしょう。

こちらの例での考え方は、該当するデータ型の変な値をとりあえず返し、エラーメッセージで知らせるというものです。当然ながら、最悪の場合はアプリが正常に動いてしまうので、エラーメッセージに気付く必要があります。

ただし、関数を呼び出す側が、正しく変換できたのか知りたい場合は、nilを返す必要があります。呼び出し側でnil検査をして、変換の成否を確認できるようにするためです。当然、戻り値にはOptional型を使うことになります。

 

ここまで2つのケースを挙げましたが、忘れてはならない大事な注意点があります。エラーが発生したとき発見しづらくなるようなら、こうした方法を使わずに、素直にOptional型を使うべきです。

少し具体的に説明します。文字列に変換する関数が、ファイル名に関係する関数だったとしましょう。そうすると、エラーが発生するかどうかは、使っている環境に依存します。念入りにテストしたとしても、予想外のファイル名が来た場合、エラーとして判断される可能性もあります。

このように特殊な実行時に発生すると、コンソールのエラーメッセージを見るという行為はできません。エラーが発生せずに何かの文字列が返り、そのまま実行が続いて、最終的には関係ない別な箇所でエラーが発生したりします。すると、最初のエラーまでたどり着くのが極めて大変になります。このような状況が予想される場合には、素直にOptional型を使ってnilを返すのが一番です。

逆にOptional型を使わないと判断して構わないのは、実行時にエラーに気付く可能性はゼロで、開発中にエラーに気付く状況しかあり得ないときだけです。ライブラリの使い方の間違いとか。それに該当するときだけ、Optional型を使わない作り方をすべきでしょう。

 

もう1つ、別な視点として、実行時エラーだけは避けたいという考え方もあります。表示する値が変になっても、実行時エラーで異常終了しないほうがよいという考えなら、エラーメッセージで知らせて、Optional型を使わない選択肢もアリでしょう。最終的には、作る人の考え方で決まります。

もちろん、この場合はプログラムの作り方も少し変わり、単にOptional型を使わないだけでは済みません。実行時エラーを発生させないのに加えて、エラーを発見しやすくしたり、関係する処理でも異常終了させない配慮が必要です。今回の話題とは別な話なので、この辺にしておきます。

 

それにしても、エラーのときにnilを返すという方法が、根本的に何とかならないのでしょうか。もっと別な形でエラーを返せるような、言語上の仕組みとか、API上の工夫とか、格段にエレガントな方法があっても良さそうに思います。

オブジェクト指向とか入ってきましたけど、根本的な部分では大きく改善されてないような感じですね。プログラミングの技術って、本当に進歩しているのか、疑問に思う部分でもあります。

 

ここまでOptional型の使い方というか、使わずに作る方法を考えてみました。読んで分かるように、これが常にベストという方法などありません。いろいろな視点で悩みながら得られた方法で、特定の視点では優れているものばかりです。最終的には、自分の考えに合った作り方を選ぶしかありません。

これから先も、Optional型に関しては悩みながら作ることになるでしょう。また何か面白い考え方がアイデアが思い付いたら、続編として紹介したいと思います。皆さんも、Optional型の上手な使い方がないか考えてみてください。

 

(使用開発ツール:Xcode 6.1.1, SDK iOS 8.1)

2015年2月1日日曜日

AnyObjectの欠点を補うクラス(全体設計編+本編)

以前に行なったAnyObjectの仕様確認で、IntやFloatを入れたときにis演算子が区別できないと判明しました。そのことを含めて、AnyとAnyObjectの違いや使い分けも検討しました。やはりAnyObjectのほうが便利であり、is演算子によるInt判定の欠点さえ解消されれば、今のところ最高の汎用データ型になれるはずです。

というわけで、欠点を補うためのクラスを作りました。そのクラスと、考慮した点を紹介します。

 

前回の投稿では、1つのクラスを用意して、IntやFloatの値を入れる形を考えました。要望を満たせる方法ではありますが、よくよく考えるとベストな方法ではありません。もっと良い方法を思いつきました。

その方法とは、Intだけを入れるクラス、Floatだけを入れるクラス、Boolだけを入れるクラスと、3つのクラスを用意する方法です。この方法なら、どのデータ型を入れているのか判断する必要はありません。入っているデータ型の判定処理が不要になることで、使い勝手は格段に良くなるはずです。

3つのクラスで実現する方法を思いついたのは、そもそも別なことを考えていた結果です。Intをクラスに変換できれば、AnyObjectに入れた後でis演算子を使うとき、そのクラスの名前で判定できるのではと思ったからです。しかし、いろいろ探してみたものの、そのような方法は見付かりませんでした(もし知っていたら教えてください)。仕方がないので、自分で作ればと考えたとき、実はそれこそが一番良い解決方法だと気付いたわけです。このような回り道する思考過程は、良くありますね。

 

非常に簡単なクラスですが、いつもどおりに全体設計を考えます。具体的に考えたほうが理解しやすいので、とりあえずIntを例に。

このクラスは、iOSが提供する様々なAPIと組み合わせて使うことになります。その場合、最も親となるNSObjectを継承したクラスとして作るのがベストです。一部のAPIと組み合わせて使えないというトラブルが防げますから。

値の入ってない状態を作らないのも大事なことです。初期化の際に値を指定する形とします。他に、値を設定したり、値を取得する機能も必要です。

このクラスのインスタンスをAnyObjectに入れた状態で、全体をシリアライズする機会も多いでしょう。そのためには、このクラス自体もシリアライズに対応する必要があります。

また、デバッグ目的で使う際の使い勝手を考慮し、インスタンスの文字列化にも対応させましょう。以上をまとめると、次のようになります。

AnyObjectを補うクラス(Int編)の要件
・iOSの各種APIと組み合わせやすいように、NSObjectを継承
・初期化するときに値を指定
・値を変更したり取得する機能
・シリアライズ可能に
・文字列化にも対応

こうして整理した要件を、もう少し具体的な機能として変換すると、次のようになります。

AnyObjectを補うクラス(Int編)の具体的な要素
・クラスの親子関係:NSObjectを継承
・クラス内の変数:入れるデータ(Int)だけ
・初期化:値(Int)を指定して
・メソッド:値(Int)の取得
・メソッド:値(Int)の設定
・シリアライズ可能に:NSCodingプロトコル準拠
・文字列化:Printableプロトコルを上書き

以上の要素を満たすように、コーディングするだけです。

 

まずはクラスの入れ物から。NSObjectを継承して、NSCodingに準拠するので、次のようなSwiftコードになりました。

// AnyObjectを補うクラス(Int編)
class IntObj : NSObject, NSCoding {
    var aoInt : Int = -99999

    init(_ rInt:Int) {
        super.init()
        aoInt = rInt
    }
}

クラス変数はIntだけで、宣言するときにダミーの値を入れています。初期化の処理では、入れる値を受け取って、変数に設定するだけです。簡単ですね。ちなみにaoはAnyObjectの略で、特別な意味はありません。

クラス名は少し悩みましたけど、Intをオブジェクトにしたという意味で、IntObjとしてみました。どんなクラスなのか、何となく伝わると思います。

 

続いて、値の取得と設定のメソッドです。これも非常に簡単です。

// 値の設定と取得
func setValueF(rInt:Int) {
    aoInt = rInt
}
func getValueF() -> Int {
    return aoInt
}

あまりに簡単すぎて、機能については説明することがありません。ただし、メソッド名に関してですが、getIntFとはせずに、getValueFとしました。他の2つのクラスと、メソッド名を統一したかったからです。

 

次は、文字列化を実現するため、Printableプロトコルへの準拠です。親クラスのNSObjectgが既に準拠しているため、上書きする形になります。

// Printableプロトコルを上書き
override var description: String { return aoInt.description }

ここでは、descriptionを使わずにString(aoInt)とも書けます。しかし、実現する機能に近い書き方が良いと考え、descriptionを使いました。

 

最後は、シリアライズを可能にするNSCodingプロトコルへの準拠です。これも短く書け、次のようなSwiftコードになりました。

// NSCodingプロトコル準拠
func encodeWithCoder(rCoder:NSCoder) {
    rCoder.encodeInteger(self.aoInt, forKey:"aoInt")
}
required init(coder rDecoder:NSCoder) {
    self.aoInt = rDecoder.decodeIntegerForKey("aoInt")
}

整数型を扱うエンコードやデコードは、それぞれ複数ありました。Swiftには整数型が何種類もあるからでしょう。API資料で比べ、Int型を対象にしたものを選びました。

 

クラスのSwiftコードは、以上で終わりです。全体が短いソースコードなので、今回だけは全部含めた形で再掲します。なお、ソースコード内の並び順は、説明した順番とは違っています。

// AnyObjectを補うクラス(Int編)
class IntObj : NSObject, NSCoding {
    var aoInt : Int = -99999

    init(_ rInt:Int) {
        super.init()
        aoInt = rInt
    }
    // NSCodingプロトコル準拠
    func encodeWithCoder(rCoder:NSCoder) {
        rCoder.encodeInteger(self.aoInt, forKey:"aoInt")
    }
    required init(coder rDecoder:NSCoder) {
        self.aoInt = rDecoder.decodeIntegerForKey("aoInt")
    }
    // 値の設定と取得
    func setValueF(rInt:Int) {
        aoInt = rInt
    }
    func getValueF() -> Int {
        return aoInt
    }
    // Printableプロトコルを上書き
    override var description: String { return aoInt.description }
}

全体としても、かなり短いソースコードです。もともと機能の少ないクラスですし、対応したプロトコルも少しだけですから。

 

Float型のクラスの場合も、Int型とほぼ同じです。Swiftコードは、次のようになりました。

// AnyObjectを補うクラス(Float編)
class FloatObj : NSObject, NSCoding {
    var aoFloat : Float = -9999.9

    init(_ rFloat:Float) {
        super.init()
        aoFloat = rFloat
    }
    // NSCodingプロトコル準拠
    func encodeWithCoder(rCoder:NSCoder) {
        rCoder.encodeFloat(self.aoFloat, forKey:"aoFloat")
    }
    required init(coder rDecoder:NSCoder) {
        self.aoFloat = rDecoder.decodeFloatForKey("aoFloat")
    }
    // 値の設定と取得
    func setValueF(rFloat:Float) {
        aoFloat = rFloat
    }
    func getValueF() -> Float {
        return aoFloat
    }
    // Printableプロトコルを上書き
    override var description: String { return aoFloat.description }
}

見てのとおりInt型とほぼ同じなので、説明は不要でしょう。

Int型と同様に、NSCodingプロトコル準拠では、浮動小数点型を扱うエンコードとデコードがそれぞれ複数ありました。API資料を見て、Float型となっているメソッドを選んでいます。

 

続いて、Bool型のクラスです。次のようなSwiftコードになりました。

// AnyObjectを補うクラス(Bool編)
class BoolObj : NSObject, NSCoding {
    var aoBool : Bool = false
 
    init(_ rBool:Bool) {
        super.init()
        aoBool = rBool
    }
    // NSCodingプロトコル準拠
    func encodeWithCoder(rCoder:NSCoder) {
        rCoder.encodeBool(self.aoBool, forKey:"aoBool")
    }
    required init(coder rDecoder:NSCoder) {
        self.aoBool = rDecoder.decodeBoolForKey("aoBool")
    }
    // 値の設定と取得
    func setValueF(rBool:Bool) {
        aoBool = rBool
    }
    func getValueF() -> Bool {
        return aoBool
    }
    // Printableプロトコルを上書き
    override var description: String { return aoBool.description }
}

これもまた、Int型とほぼ同じです。

 

以上、3つのクラスを作りましたが、どれも最低限の機能しか持たせていません。いつものように、何か追加が必要になったら、そのときに追加すればよいと思います。

長くなったので、これらクラスの使用例は次回にて。

 

(使用開発ツール:Xcode 6.1.1, SDK iOS 8.1)

2015年1月9日金曜日

ファイル閲覧機能のライブラリ化(全体設計編)

今まで作ったアプリには、Documentsフォルダ内のファイルを閲覧する機能を付けました。アプリで作成したデータや、環境設定ファイルなどを、Documentsフォルダに保存しているからです。ファイル閲覧機能があると、どんな状態なのか簡単に調べられ、トラブル発生時に役立つと考えたからです。その機能を最近になって独自ライブラリに加え、どのアプリにも簡単に追加できる形に仕上げました。それを何回かに分けて紹介します。

 

Documentsフォルダのファイル閲覧機能と言っても、作り方は様々です。私が作ったのは、画面の左側にTableViewを配置し、そこにファイル名の一覧を表示させます。その中の1ファイルを選択すると、画面の右側に配置したTextViewにファイルの内容が表示されます。全部を一度に表示できない場合でも、スクロール可能に設定してあるため、ファイルの内容は最後まで見れます。

表示されたファイルは編集できないものの、全体または部分を選択して、クリップボードへコピーする機能を付けています。選択機能はiOSに付属のものを利用して、選択した部分だけコピーする形です。さらに使い勝手を考慮し、ファイル全体をコピーするために専用ボタンも追加しました。

ちなみにクリップボードですが、iOS上ではペーストボードという名前です。しかし、開発したアプリのユーザーの多くがパソコンと併用しているため、アプリが表示する名前をクリップボードで統一してあります。これ以降の説明でもクリップボードで通しますで、ご注意を。

アプリがDocumentsフォルダに保存するファイルはテキスト形式だけなので、該当する形式のファイル名だけをTableViewに表示しています。その中の1つを選択すると、選ばれたファイルの内容をTextViewに表示するという形です。

このように単純な機能なのですが、アプリのDocumentsフォルダの状態が簡単に見れて、iPad実機で何か調べたいときに重宝します。実機のままだと、Documentsフォルダが簡単に覗けませんので。

 

ライブラリ化するために、よく考えて仕様を決める必要があります。まずは、設計方針からです。このような機能を作る場合、画面表示も含めて、いくらでも凝れます。しかし、凝れば凝るほど、iOSが何度も更新されるに従って、互換性が低下する可能性が増します。できるだけ長く、修正せずに済ませられるように、まったく凝らないという設計方針にしました。

具体的には、次のように配慮します。互換性が一番低下しそうなのは、UI部品でしょう。そこで、UI部品は素のまま使い、余計な機能は何も追加しません。TableViewの選択表示も素のまま使い、TextViewの選択機能もそのまま利用します。

実現する形としては、どの画面にでも貼付けやすくしたいので、UIViewのサブクラスとして作ることにします。そうすればUIViewが持つすべての機能が使えるとともに、余計な機能を作らなくて済むため、将来への互換性も高く維持できるはずです。

UIViewではなく、UIViewControllerとして作るという方法もあります。この2つの違いというか使い分けに関して、いろいろと調べましたが、納得できるほどの方法は得られていません。今のところ、画面全体を扱う場合はUIViewControllerを、画面の一部として貼付ける場合はUIViewを用いています。この使い分け方が、それぞれの本来の役割に近い形ではないかと思うからです。今回のものは画面の一部になるため、UIViewを選びました。

 

UIView形式で作るときに問題となるのが、表示する大きさに合わせたレイアウト変更です。指定されたサイズに合わせて、表示するUI部品の大きさも変更しなければなりません。こうしたレイアウトの表示ルールをきちんと決めておかないと、見た目や使いやすさなどが低下してしまいます。

ただし、どんな大きさを指定しても大丈夫に作るのは無理ですから、最初に最低の大きさを決めます。今回の場合は、あえて小さく表示する必要がないため、とりあえず幅が800で高さが500と仮決めしました。このような値は、作成後に使ってみて調整すれば良いでしょう。

次に決めるのが、要素の大きさと配置です。今回のUIViewは配置が決まってますから、各UI部品の大きさだけです。左側のTableViewは、幅を狭くすると長いファイル名が読めなくなるので、幅は固定としました。右側のTextViewの幅だけが可変です。縦方向は、TableViewもTextViewも同じ高さで、両方とも可変です。

その他のUI部品としては、右下にコピーボタンを付けます。TextViewで選択したファイル内容を、クリップボードにコピーするための機能です。さらに、コピーボタンの左側にメッセージ欄を加えます。コピーの成功など、操作結果を知らせるためのメッセージ表示に使います。

あと全体で、余白も付けることにしました。UIViewの境界ギリギリにUI部品などを表示させると、高解像度のモニターで描画が正しくない可能性もあるので、安全のために余白は必須だと思います。

 

境界ギリギリも含めて、描画については少し説明が必要でしょう。iOSの描画機能は、座標をCGFloatで管理し、最終的な表示装置に向けてビットマップ画像を生成します。これが、実は曲者なのです。

すべての線には、描く太さがあります。例として、太さ1(単位の名前は不明:CGFloatの値が1)の黒線を描く場合を考えましょう。描く座標の位置は、値が10の位置とします。解像度が2倍のレチナ・ディスプレイなら、2ピクセル幅の黒線として描かれます。

しかし、解像度が1倍の通常ディスプレイなら、1ピクセル幅の黒線ではなく、2ピクセル幅のグレー線として描かれます。こうなる理由は、描く座標の位置に深く関係しています。座標10の位置は、ディスプレイのピクセルの境目にあります。そこを中心に描くのですから、座標10の位置の両側に、幅0.5の線が描かれる結果となります。しかし、通常ディスプレイの解像度は1です。幅0.5の線は描けず、幅1のグレー線として描かれるわけです。幅0.5の線2本を描いた結果として、2ピクセル幅のグレー線になってしまいます。

逆に、解像度が2倍のレチナ・ディスプレイは、ピクセルの幅が0.5ですから、座標10の両側に幅0.5の線を描くのに適しています。結果として、2ピクセル幅(合わせた線の太さは幅1)の黒線が描かれるというわけです。

以上のように、ディスプレイの解像度の違いにより、また描く座標位置の違いにより、同じ線でも描かれ方は少しずつ変わります。さらに、これがUIViewの境界に接していたら、どうなるでしょうか。考えたくもないですね。描く線の幅にもよりますが、最低でも幅1以上の余白を確保するのが、極めて賢明な選択だと分かるでしょう。

実際には、後から線を太くする変更もあり得るため、その際でも余白の値を変更しなくてよい形に作るべきです。そのためには、もっと多くの余白を確保したほうが安全です。今回は、境界ギリギリまで描く必要がないため、キリのよい値として上下左右とも幅10の余白を付けることにしました。こうすれば、UIView境界の描画を気にする必要はありません。

 

次は、TableViewに表示するファイル一覧に関してです。今まではテキスト形式のファイルだけでしたが、ライブラリ化する以上、それ以外のファイルが存在する前提で考える必要があります。テキスト形式以外のファイルが含まれていても正常に動くのはもちろん、それらが存在することが分かるように作るべきでしょう。

ファイル名の一覧には、別な役割もあります。Documentsフォルダ内のファイル名一覧を表示することは、フォルダ内の状態を見せる意味もあります。表示できないファイルも含めて、フォルダ内にある全部のファイル名を表示したら、それはそれで何かの役に立つでしょう。

ということで、次のような仕様にしました。テキスト形式以外のファイル名も一覧には表示し、テキスト形式ファイルと明らかに分かっているファイルだけ、右側のTextViewに内容を表示します。テキスト形式かどうかは、ファイル名の拡張子で判断します。予め決められた拡張子のファイルだけで、ファイル内容を表示する形です。

 

もう1つ考えなければならないのは、ファイル名一覧の更新機能です。これまで作ったものは、更新機能がありません。表示したときに一覧を表示して、そのまま最後まで使います。

更新機能を付けないのには、理由があります。iOSアプリの場合は、ウィンドウを開いて使い終わったら、消してメモリーを開放するというのがマナーになっています。見終わったら削除し、再び見るときには新たに表示するので、更新機能が不要というわけです。今回も、そのマナーに従い、更新機能は付けないことにしました。

 

ここまでの検討で、全体の仕様が見えてきました。箇条書きで整理すると、次のようになります。

ファイル閲覧機能の大まかな仕様
・UIViewのサブクラスとして作る
・表示サイズをチェックして、最低値より小さいならエラー
・凝った機能は追加せず、UI部品を素のままで使う
・構成するUI部品は以下のとおり
 ・TableView:ファイル名の一覧で、1つを選択可能
 ・TextView:選択したファイルの内容を表示(テキスト形式のファイルのみ)
 ・Button:TextViewで選択したテキストを、クリップボードにコピー
 ・Label:各種メッセージの表示
・レイアウトに関して
 ・上下左右に幅10の余白
 ・横位置の計算:TableViewは固定、TextViewは可変
 ・縦位置の計算:TableViewもTextViewも可変
・実装する機能
 ・ファイル名の一覧を、TableViewに表示する(オープン時に自動で実行)
 ・TableViewで選んだファイルの内容を、TextViewに表示する
 ・TextViewの表示内容を、クリップボードにコピーする

今まで作ってきたクラスとは異なり、用意したメソッドを呼び出して動かす形ではありません。最初に表示した状態で、それぞれのUI部品に機能を割当てます。UI部品が操作されたときに、割り当てられた機能が実行されるという形です。

こうした形なので、仕様では「メソッドの一覧」の代わりに、「実装する機能」としてまとめました。

 

ここまで仕様が固まると、あとは作るだけです。しかし今回は、過去のアプリ内で作ったSwiftコードがあります。それを使えば、最初から作るよりは、はるかに簡単です。

UIViewのサブクラスとして作るわけですから、全体の大枠は変わります。でも、ソースコードの多くは、該当する箇所へコピーして使えました。仕様が変わった部分だけ手直しして、変更も意外に早く終わりました。いったん作ったものなので、構成を変えるだけだと簡単ですね。

次回の投稿では、そのSwiftコードを取り上げます。

2015年1月5日月曜日

当ブログの中心は、アプリ開発の設計視点

当ブログにおける今までの投稿をほとんど読んだ方なら、他のブログとは違った視点から書かれていることに、お気づきだと思います。今回は、その辺の話を少し書いてみます。

 

世の中には、ブログだけでなく雑誌も含め、プログラミングに関する多くの情報が出回っています。また、新しい情報が次々の加わってもいます。それらの情報をたくさん手に入れたら、アプリ開発が上手になるのでしょうか。

残念なことですが、非常に重要な要素が欠けています。アプリ開発において一番重要かもしれない、全体設計の話です。アプリの大まかな構造をどのようにして導きだすのか、どんな点に注意して設計すれば良いか、どのような視点でアプリを改良するべきか、といった話です。残念なことですが、そのような情報はほとんど(まったく?)出回っていません。

ちなみに、ブログや雑誌で扱っている主な情報を挙げると、次のようになります。

世の中に出回っている主な情報
・開発ツールの操作方法
・プログラミング言語の説明
・目的の機能を実現するためのソースコードと解説
・設計の小技(デザインパターンなど) 
・オブジェクト指向などの基礎的な考え方

これらに該当する話は、検索すれば数多く見付けられます。また、どんどんと新しい内容に更新されてもいます。しかし、より上位の設計の話は、ほとんどないのが実状です。

 

ソフトウェア設計の技というと、最近ならデザインパターンを思い浮かべる人が多いと思います。デザインパターンを短い言葉で表現するなら、オブジェクト指向ならではのクラス構成術というのがピッタリでしょう。

デザインパターンも、ソフトウェア設計には含まれますが、アプリ全体の設計を考えるレベルの設計術ではありません。もっと細かな機能を、オブジェクト指向的に作るためのパターンです。あえて最良と書かずに、オブジェクト指向的と書いたのは、それが別な視点で見たとき、最良の設計とは限らないからです(この辺の話は、機会があれば詳しく書きます)。

けっして、デザインパターンが不要だと言っているのではありません。それよりも上位の設計術が大事で、その設計内容に従った形で、デザインパターンが使われるということです。投稿「雑誌などのソースコードは再構成して使う」で書いたように、私の分類では3番目に位置するのがデザインパターンです。

変更への柔軟性や、再利用を重視したソースコードを作る視点(再掲載)
1. 機能の切り分け(インターフェースの標準化も含む)
2. 間接参照を多用する
3. オブジェクト指向の利点を利用する(デザインパターンも含めて)

この3段階の視点は、アプリ設計における重要な順番で並べてあります。このうちの上位2つが、このブログで中心に置いている視点です。

 

ただし、この上位2つの視点も、当ブログが重視している視点の結果でしかありません。もっと基本的な視点により、アプリ開発の重要点をノウハウ化しようと努力しています。具体的な視点を挙げると、次のようになります。

ブログで取り上げている重要な点
・どのような視点で設計しているのか?
・どんな点に注意しながら設計すれば良いのか?
・設計の質を高めるには、どうすれば良いのか?
・トラブルを未然に防ぐためには、どんな点に注意すべきか?
・メンテしやすい設計とは?
・ユーザーが安心して使える設計とは?

思いつくまま挙げたので上手に整理されていませんが、言いたいことは伝わると思います。全体としては、アプリ開発における、より上位の視点を集めたものと言えるでしょう。

 

視点だけが良くても、書く内容の質は高められません。やはり、書き方も重要です。できるだけ役に立つ内容に仕上げようと、次のような点を心掛けています。

書くときに注意している点
・どんな点を考えて設計しているのかを、一番重視して書く
・細かな考慮点も、できるだけ取り上げる
・考えられる選択肢を列挙して、判断基準や選択結果を示す
・仕方なく選択した点なども、その理由とともに判断過程を説明する
・最終的には、ソースコードとして仕上げる
・示したソースコードに仕上げた理由も、できるだけ説明する
・開発資料(API資料やサンプルコードなど)の問題点やその対処方法も取り上げる
・調べれば簡単に分かる内容(APIの基礎的な使い方など)の説明はできるだけ省く

すべて出来ているとは言えませんが、私としては頑張って書いているつもりです。

 

以上のようなことを考えながら、このブログを書いています。時間の制約もありますし、伝えるのが難しい内容だけに、どれぐらい書けているか(読み手にも影響を受けますが、どれぐらい伝わっているか)は、少し不安を持っています。それでも、書ける範囲内で書き続けていたいと思います。同じ方向性のことを書いている人が、ほとんどいませんので。

 

アプリ開発で何が大事かは、作る人によって違うでしょう。もし当ブログで書いてある内容に共感できるなら、役立つ情報(しかも他では得られにくい情報)が数多くあると思います。どんどんと吸収し、自分なりのノウハウとして改良しながら、活用してください。

2014年12月13日土曜日

雑誌などのソースコードは再構成して使う

新しい言語や使ったことのない機能などを学ぶ場合、雑誌やウェブにあるサンプルのソースコードを参考にする人は多いと思います。当然ですが、私もその一人です。数多く目にするソースコードですが、「アプリに利用する場合」は、そのまま使ったり、ほぼ真似て作るのはお薦めできません。それには大きな理由があるので説明します。

 

そもそも、雑誌やウェブ、またはメーカーが提供するソースコードの目的は何でしょう。たいていの場合は、作りたい機能を実現することです。つまり、機能の実現を重視したソースコードとして書かれています。

そうした目的のために一番適したコーディング方法は、具体的な命令文をベタで書くことです。説明のためのコメントは加えますが、それ以外では命令文だけをベタに記述します。どのような命令を組み合わせ、どの順序で並べれば確実に動くのか、もっとも理解しやすい方法だからです。

命令文をベタに羅列する書き方は、命令文以外の要素が含まれません。そのため、余計な説明が不要になります。再利用のために何々を工夫したとかいう話は、目的の機能を実現するためには関係ないのです。つまり、機能の実現方法を説明する目的には、命令文をベタに書く方法が最適なわけです。

 

では逆に、アプリを開発するときのソースコードは、どんな点を考えて書かれるのでしょうか。もちろん、人によって考えは違うでしょう。でも、アプリ内の構造を上手に作るとしたら、意見の違いは少ないのではないでしょうか。いろいろな点が考えられますが、実現するのが難しくて、もっとも重視したい点となると、変更への柔軟性です。将来の拡張を十分に考慮し、変更が発生したときの手間が最小限で済むように、いろいろと工夫して書くはずです。

次に挙げる点としては、コードの再利用があります。一度作った機能は、別なアプリで使うときに、手直しせずに使えたら非常に助かります。新しく書くソースコードの量が減るからです。無駄な開発作業を減らす、もっとも有効な手段でしょう。

つまり、ソースコードを作る目的というか、どんな点を重視してソースコードを書くのかが、雑誌のサンプルとアプリ開発では根本的に違っているということです。この点に気付かない人が、意外に多いかもしれません。

 

少し余談になりますが、柔軟性や再利用以外の考慮点として、実行速度が挙げられます。最近は、それほど気にしなくて良くなりましたが、完全になくなったわけではありません。ただし、以前とは状況が違ってます。

実行速度が問題になりそうなアプリを作るときでも、何から何まで速度重視で作るケースは減りました。ツールが発達したことで、ネックになっている処理部分が見付けやすくなったことも大きいです。速度重視の開発でも、手順としては次のように行なうケースが増えていと思います。最初は、スッキリした構造で作り、一応の機能を完成させます。もし遅くて困る機能が発見されたら、解析ツールを使って、遅い原因となっている処理を特定し、その部分に改良を加えます。こうした手順だと、全体として良い構造を確保しながら、速度問題も解決できる可能性が高まります。

もし最初から処理速度が問題になりそうなアプリでも、開発を始める前に大まかな解決方法を考え、その方法に沿いながら、アプリの構造を良くする方法まで検討します。良い構造を抜きにして開発するのは、もう受け付けられない状況になっていますね。

 

話を戻して、変更への柔軟性や再利用を重視した作り方を取り上げましょう。具体的には、どのようなソースコードになるのでしょうか。

まずは、よく使う機能のライブラリ化です。同じ命令コードを繰り返し書かなくて済むように、機能ごとにまとめて、異なるアプリでも共通して使えるように作ります。クラスとして作る場合も、関数群として作る場合もあるでしょう。どちらにするかは、実現する機能の特徴に加え、プログラマーの好みにも関係するでしょうね。いや、本当に好みなんですよ。

さらに考えるのは、機能の切り分けと、切り分けた部分のインターフェースです。たとえば、アプリで作成した内容を、プリンターで印刷したいとします。大きく分けて、印刷内容を生成する処理と、その内容をプリンターに渡して印刷する処理が考えられます。後者の処理は、使用するプリンターに依存し、プリンターごとに作る必要があります。

そうなると一番良い切り分け方は、次のようになります。印刷内容を生成する処理を独立させ、プリンターへ渡す部分のインターフェースを標準化することです。プリンターに渡して印刷する処理は、プリンターごとに作りますが、標準化されたインターフェースに準拠して作るわけです。

こうすると、次のようなメリットが生まれます。印刷内容を生成する処理では、プリンターを切り替えても、修正する箇所が最小限で済みます。同時に、プリンターを扱う処理も独立でき、別なアプリへ持っていきやすくなります。インターフェースを標準化していますから、持っていった別なアプリでも、複数のプリンターを切り替えたとき、呼び出す側の変更が最小限で済みます。

このように見ていくと、機能の切り分けが重要であると理解できます。それぞれの機能が交換しやすく、また他へ持っていきやすくなるように、上手に切り分けることです。さらに、切り分けた部分のインターフェースを標準化して、切り分け後の同種機能を交換可能に作る点も、非常に重要です。上手な切り分けと、切り分けたインターフェースの標準化が、ソフトウェア設計で非常に重要なことなのです。

現在はオブジェクト指向プログラミングが広く普及していますが、これらの切り分けは、オブジェクト指向には依存しません。古くから使われている手続き型のプログラミング言語でも、簡単に実現可能です。その意味で、プログラミング言語の種類に依存せず、もっとも基本的な設計方法と言えるでしょう。

ライブラリ化も含めて、機能を区切る際に一番重要なのが「どこで区切るか」です。上手に区切らないと、メリットを大きくできません。考え方としては、似た機能を交換できるか、そのまま別なアプリへ持っていけるか、という点を重視して決めます。場合によっては、区切りを2段階にして、交換できる可能性を増やすこともあります。何度も試して経験する中で、少しずつ上手になると思います。

 

続いて、広く役立つのが間接参照です。色などの値を定義して、それを参照する使い方が一般的でしょう。上手なプログラミング手法として、C言語などでも古くから使われています。

それ以上に役立つのが、関数などの処理を通した間接参照です。関数を間に入れることで、色々な機能を盛り込めます。たとえば、現在の時刻を得る関数を用意して、アプリに含まれる全部の時刻参照で、その関数を使っているとします。すると、その関数の処理を変更し、通常よりも時間が速く進む機能を加えたり、指定した時間分だけ時刻を早めたり遅らしたりも可能になります。さらには、特定の日付時刻で実行させるといったトリックも、簡単に実現できます。

アプリ上では、メッセージを表示するためのUI部品を付けるでしょう。その場合、UI部品を直接参照するのではなく、UI部品を参照するための関数を用意するのが、間接参照による作り方です。メッセージを表示する個々のソースコードでは、UI部品での代わりに関数を呼び出す形になります。すると、メッセージ表示に特別な機能を追加したいとき(表示時刻を追加するとか)、関数だけを修正して対応できます。

値定義でも関数でも、事前に間接参照を使っておけば、1カ所を変更するだけで、参照している全部の値や機能を変えられます。つまり、変更への柔軟性が高いプログラムになるわけです。

 

以上のような工夫を数多く用いると、どのようなソースコードになるでしょうか。よく使う機能はライブラリ化して、用意した関数やメソッドを呼び出す形になります。間接参照を多用すると、値定義や関数を呼び出す形が増えます。

結果としてソースコードは、関数やメソッドが中心となり、ベタで書いた命令文の率が極端に減ります。雑誌などの見かけるような、命令文をベタで書いたソースコートとは、まったく別物に見えるはずです。アプリ内部の構造を上手に作れる人ほど、その傾向が強いでしょう。

 

ここまでの話を理解すると、ソースコードの作り方が大きく変わると思います。雑誌などのソースコードを参照しても、そのままコピーして使わずに、個々の命令文をプログラム部品として用いながら、アプリ全体の構造に当てはめていくでしょう。まるでソースコードを再構成するような感じで。

よく使う機能をライブラリ化したり、同類の機能と置き換えやすいように処理内容を区分けしたり、そのインターフェースを標準化したり、いろいろな箇所で間接参照を組み込んだり、様々な工夫が思いつくはずです。こうした考え方で、アプリの内部を設計すれば、優れた構造で作れると思います。

 

プログラムの再利用の話になると、オブジェクト指向の話が必ず登場します。でも、オブジェクト指向のプログラムング言語を使い、それを生かしたブログラミング手法(デザインパターンなど)で作ったとしても、再利用しやすいソースコードになるとは限りません。

たとえば、小型プリンターRoltoのサンプルコードは、Objective-C言語を用い、オブジェクト指向の考え方で書かれています。しかし、プリンター処理がアプリ処理と一体化しているため、プリンター処理だけ独立して、他のアプリへコピーしては使えません。また、他のプリンターに切り替えたとき、アプリの処理もかなり変更しなければなりません。最近使ったという理由でRoltoを例に挙げましたが、他のプリンターでもほとんど同じです。

これらのソースコードは、前述したように、ドライバーの使い方を説明するのが目的です。そのため、再利用しやすいコードを目指してはいません。結果として、オブジェクト指向に則って作りながらも、再利用しづらいソースコードの例となってしまいました。

つまり、オブジェクト指向も道具の1つでしかなく、より上位のレベルでのソフトウェア設計において、再利用を考慮することが大事だということです。ここで書いたようなアプリ設計の考え方を採用することで、オブジェクト指向の利点が、さらに有効に活かせるようになります。

 

ここまでの話を、最後に整理しましょう。大事な順に並べると、次のようになります。

変更への柔軟性や、再利用を重視したソースコードを作る視点
1. 機能の切り分け(インターフェースの標準化も含む)
2. 間接参照を多用する
3. オブジェクト指向の利点を利用する(デザインパターンも含めて)

この中では、オブジェクト指向だけが特殊です。他の上位2つは、オブジェクト指向のブログラミング言語でなくても利用できる、ソフトウェア設計術に位置づけられます。

アプリを開発する際には、ここで取り上げたような視点で、アプリの内部構造を考えてみてはいかがでしょう。そうすれば、雑誌などに載っているサンプルのソースコードをそのまま使わず、細かな命令文を部品として再構成するようになり、変更への柔軟性が高くて再利用しやすいソースコードが得られるはずです。

2014年12月5日金曜日

オフスクリーン描画をライブラリ化(全体設計編)

オフスクリーン描画機能をライブラリ化する話の続きです。今回は、全体設計の話を書きます。作り始める前に、どのような形で作るのか決めておかないと、無駄な作業が増えますからね。

 

私がオフスクリーン描画機能を使うのは、画面で表示する描画部品に加え、印刷内容を描くときです。いくつもの要素を描くのですが、同じ色で描く要素が多くあります。より具体的には、数十個の要素を、数色の色で描くという感じです。

実現したい動作としては、使う色をあらかじめ登録しておき、登録した色を指定しながら要素を描くという形です。複数の色を登録する機能、その色を使って図形や文字を描く機能が必須です。また、描くサイズを指定して描画を開始する機能、描き終わった内容をUIImageに出力する機能、描画を終了する機能も必要となります。

今回の描画機能は、クラスとして実現します。手短くまとめて、次のような全体像としました。

オフスクリーン描画機能のクラス
・描画の開始メソッド(描画サイズなどを指定)
・描画の終了メソッド(UIImageに出力して描画を終了)
・色の登録メソッド(線色と塗りつぶし色を指定:複数の登録が可能に)
・各種図形や文字の描画メソッド(登録した色を選択:大きさや線幅なども指定)

まとめると以上ですが、具体的に作り始めると、各種図形の部分が何種類にもなります。使うものから作り始めて、順次増やしていくのが現実的でしょう。

 

図形を描くメソッドと、色の登録メソッドを分けたのには、別な理由もあります。図形を描画するメソッドには、位置や大きさなど何個もの引数が必要です。これに色を加えると、引数が非常に多いメソッドになります。メソッドを使う側のソースコードには、引数が多いメソッドが並んで、美しくないですし、処理内容を読み取りづらくもなります。

色の指定を別なメソッドとして用意し、描画メソッドでは登録色を選ぶだけだと、描画メソッドの引数が減らせます。また、同じ色を何度も指定する無駄も解消できます。色の登録を別メソッドに分割することで、使う側のソースコードを読みやすくするという効果もあるのです。

 

全体像が決まったので、実現方法の検討に移ります。決めた形で実現できなければ、全体像を作り直さなければならないため、実現方法の検討は大事です。

iOSの描画機能では、色の指定も含めてCGContextを使います。まずCGContextを用意して、色や線の太さなどを設定します。設定したCGContextを指定しながら、目的の図形を描く命令を実行するという手順です。

最初は、次のように考えました。CGContextを複数保持して、それぞれのCGContextに色を設定します。図形を描く際には、目的の色に設定されたCGContextを指定して、描画命令を実行するという形です。

この考え方で実現できるかどうか、実験専用アプリで事前試験をしてみました。すると、大変なことが判明しました。必要な数だけCGContextを保持(変数で参照)したあと、あるCGContextを変更しても、全部のCGContextが変わってしまいます。当たり前ですね。同じCGContextを参照しているからです。

これを防ごうと、CGContextの深いコピーを作ろうとしました。でも、CGContextにはcopyメソッドが実装されておらず、コンパイルエラーになってしまいます。さらに、CGContextを新規で作る機能も用意されていないので、CGContextを複数保持して切り替えるという当初の案は暗礁に乗り上げてしまいました。

 

こんなことぐらいでは、あきらめきれません。こうなったら作戦変更です。CGContext自体を保持するのではなく、CGContextに設定する値を複数保持して、描画する直前にCGContextへ設定する方法を試します。

CGContextに設定できる属性は多数あります。全部を保持すると大変なので、今回は色だけに限ることにしました。線色と塗りつぶし色の2つだけです。この2つを登録できるだけでも、私に取っては十分に便利な描画機能になりますから。

この実現方法なら、あらためて実験する必要はありません。今まで使ったことのある機能の組み合わせで、簡単に実現できてしまいます。作成の障害はなくなりました。あとは実際に作るだけです。さらに細かな仕様は、これまでと同じように、実際に作るとき考えましょう。

 

作り始める前に考えたり実験したのは、以上のようなレベルまでです。ここまで整理できていると、あとは淡々と作り進むだけですね。実際、一気に作り終わりました。次回から、具体的なソースコードを紹介します。

2014年11月29日土曜日

業務アプリはデータ保全が一番大事

業務で使用するアプリの開発は、一般的なアプリと少し違うと思います。少なくとも私は、違うと考えて開発してます。どのような点を重視しているのかというと、入力したデータを可能な限り守ることです。iPadという環境なので大したことはできませんが、できないながらも工夫した点を紹介します。

 

アプリを仕事で使うということは、仕事上のデータを扱うということです。扱うというと抽象的なので、もっと具体的に言うと、仕事上のデータを入力して保存して活用するということです。こうして入力したデータは、会社の財産です。そのため、入力されたデータが失われないことを、業務アプリでは一番重視しています。

データを保存する場所としては、RAMメモリー内よりもフラッシュメモリー内のほうが格段に安全です。RAMメモリー内なら、アプリが異常終了したときに、データが失われてしまいますから。こうした理由から、データを入力した直後に、ファイルへ保存する形で作っています。iPadのファイルはフラッシュメモリー内に保存されるため、機械的なアクセスもなく、ハードディスクよりも安全で高速です。

毎回保存されるのを気にするかもしれませんが、タップ操作でアプリへ入力するデータの量などは、たかが知れています。圧縮などせずにテキストで保存したとしても、データ量が少なく、一瞬で書き出されます。

 

ファイルへ書き出す場合にも注意が必要です。もし書き出し中にエラーが発生したら、そのファイルは正常に読めなくなるかもしれません。もし読めたとしても、途中までのデータしか残っていない可能性があります。

書き出しに失敗した場合を考慮すると、毎回異なるファイル名で書き出し、どんどんと追加する方法もありますが、ファイル数が増え過ぎて現実的ではありません。同じファイル名に書き出しながら、失敗へのリカバリー方法も考慮するという手段が現実的でしょう。

最初に考えたのは、仮のファイル名で書き出し、書き出しが成功したら本来のファイル名に変更する方法でした。でも、先にあったファイル(つまり前回に保存したファイル)を、どう扱えば良いのか悩みました。そして次のような方法を採用しました。

保存するファイル名は毎回同じで、新しく入力したデータを後ろに追加してから保存します。同名の古いファイルは、旧版として過去3世代ほど残しておく方法です。

過去3世代が残っている状態だと、最新ファイルに加えて、old1、old2、old3という3個のファイルが存在することになります。その状態で新しく保存する場合、具体的な実行手順は次のようになります。

3世代を残しながら更新する手順
・old3ファイルを削除する
・old2ファイルをold3に改名する
・old1ファイルをold2に改名する
・最新ファイルをold1に改名する
・新しい最新ファイルを書き出す

oldが存在しない状態(使い始めたときの状態など)もありますから、個々の処理では、改名する前に存在を確認し、存在すれば改名するという形になります。

 

過去3世代のファイルを残しておいても、書き出しが失敗したとき、元に戻す機能がないと無駄です。リカバリー処理の1つとして、過去3世代を1つずつ戻す処理が必要となります。具体的な実行手順は次のとおりです。

旧3世代を1つずつ戻すリカバリー処理
・最新ファイルが存在すれば削除する
・old1ファイルを最新名に改名する
・old2ファイルをold1に改名する
・old3ファイルをold2に改名する

これらでも個々の処理では、改名する前に存在を確認し、存在すれば改名するという形になります。

リカバリー手順は以上で構わないのですが、最新ファイルの書き出しに失敗しているか調べる方法が必要となります。最終的には、人の目で確認するのが一番でしょう。最新ファイルだけでなく、old1〜old3も含めて、中身を見れる機能も用意しました。

通常の作業で、これらのリカバリー処理を使うことはありません。アプリが突然と異常終了したとか、入力後の保存処理で成功メッセージが出なかったときなど、普段と違う表示になったときに利用するものです。調べる手順などをヘルプに書いておき、そのヘルプを読みながら、リカバリー処理を進めるという形にしてあります。

一番長く使われている業務アプリでも、Titanium mobile時代も含めて3年ぐらいしか経過してませんが、異常な状態になったことは一度もありません。そのため、これらリカバリーの処理は何度もテストしましたが、まだ本番では一度も使われたことがないのです。良いことといえば、良いことなのですが。

 

アプリのトラブルは、データ入力時に起こるとは限りません。予想もしないトラブルが、突然と発生することも考えられます。たとえば、iPadの調子が悪くなって、どのアプリも不安定な動きになったとかです。こんな状態だと、いつiPadが起動しなくなるのか不安でしょう。真っ先にすべきことは、iPad内の重要なデータを、他のマシンにコピーすることです。

iOSのアプリでは、Macと接続したとき、iTunesでバックアップが取れるようになっています。その際、アプリ側の設定で、iTunesからアプリの保存ファイルが見えて読めるようにもできます。Info.plistファイルの項目で、「Application supports iTunes file sharing」を追加してYESに設定するだけです。こうしておくと、もし近くにMacがあれば、iPadと接続して全ファイルをコピーできます。

近くにMacが無い場合も考慮し、ファイルを添付して送信できるメール機能も追加しました。ファイル一覧をテーブルビューに表示し、添付したいファイルを選んで、他のマシン宛に送信するだけです。

毎日使われている業務アプリでは、この送信機能を通常業務としても利用しています。iPadで入力した業務データは、1日単位でファイルに保存されています。それをメール機能でMacに送信し、Mac側の表計算アプリに取り込んで、業務分析などに利用しているのです。メール機能を付けたために、iPad側は入力中心になってしまいました。将来的な話ですが、iPadがパソコン的に使えるようになったら、分析業務もiPadでやりたいそうです。その前に、クラウド上の表計算機能が使えるようになって、iPadとクラウドだけで十分になりそうですけど。クラウド側だと、バックアップとしても安心ですし。

ちなみに、業務アプリ開発の相談を受けた場合、最初に提案するのがサーバーを立てて、iPadからはウェブブラウザで使う形です。クライアント側のOSやアプリに依存せず、サーバー側だけでシステム更新が可能だからです。でも、パソコン上の表計算アプリでバリバリとデータ解析するような人は、サーバーを立てずに、iPadで入力専用のカスタムアプリを使いがるようです。主に小さなお店のオーナーですけど。

 

アプリ側のトラブル対処機能だけでは、十分な安定性を確保できません。動作環境であるiPadの使い方も、安定性が増すように注意する必要があります。iPad環境をどのように整えたら良いのか、アプリ内のヘルプとして記述しました。

その内容は、一般的なパソコンの注意点と同じです。余計なアプリを、できるだけインストールおよび起動しないこと。フラッシュの空き容量を十分に確保すること。アプリは何日も連続して使えるように作ってありますが、できれば毎日の業務終了後にアプリも終了し、1日1回は再起動してクリーンな状態で使うこと、といった具合です。こういう大事な点を知らせておくと、余計なトラブルを起こさずに済みます。

iPadのように、部品のほとんどが電子化されている機器の場合は、初期不良を除くと、あまり壊れないのではないでしょうか。機器の故障よりも、落下させたなどの人為的なミスで壊れる可能性が高いでしょう。それも、iPadにカバーを付けることで、大きく壊れることは防げます。機械的な破損の場合は、液晶画面が割れたまま動き続ける可能性もあり、その状態でならデータをコピーできます。そういった面も含め、データを守ることの大切さをユーザーに伝えることも、大事な仕事ではないかと思います。

 

アプリが異常終了してもデータを守る話を書きましたが、そもそもアプリが異常終了しないように作るのが大前提です。アプリが安定して動作するように、トリッキーな作り方を避けるのはもちろん、動作が少し遅くなっても構わないので、安全な作り方を選択するように心がけています。また、iOSアプリの基本ルールである「使い終わった画面は終了してメモリーを開放する」という形で、メインメニュー以外の画面を作っています。

おかげさまで、データを失うようなトラブルは、まだ起こっていません。「手を抜かないで真面目に作っているほど、安定して動く」という、先人の言葉を参考にしながら開発しています。

2014年11月6日木曜日

Roltoへの印刷機能をswiftで書く(全体設計編)

どんな機能でも、ある程度の設計方針を決めてから作り始めないと、効率が悪いのはもちろん、仕上がりまで悪くなりがちです。ただの印刷機能ですが、全体の構造を先に考えました。今回は、その辺の話でも。

印刷機能といっても、いろいろな要素が含まれます。プリンターのドライバーと関わる部分、印刷内容を作る部分、ユーザーインターフェースに関わる部分などです。これらをどのように組み合わせるのか、どのように分割するのかを考えるのが、全体設計です。構成要素への分割だけでなく、要素間のインターフェースも含みます。

 

まずは、プリンターに近い部分から。プリンターを用いた印刷のような、特定の機器に依存する機能は、機器へ依存する箇所をできるだけ少なく作ることが大切です。つまり、別なプリンターを追加したり切り替えたときに、印刷機能を利用する側の変更が、少なくて済むように作るということです。具体的には、プリンターとやり取りするインターフェースを、特定のプリンターに依存せず、どのプリンターでも共通の仕様にしておきます。

プリンタを利用するための一般的な機能として、次のように洗い出してみました。

プリンターのクラスで用意する機能
・プリンターの検索と登録
・プリンターの状態確認
・プリンターで印刷
・印刷のキャンセル
・プリンターの解放と登録解除

これらをメソッドとして用意すれば、プリンターを切り替えたときの、プリンターを利用する側の変更が最小限で済みます。メソッド名も、機種に依存しない一般的な用語で作るのは当然のことですね。

クラスの作り方としては、プリンター全体のスーパークラスを先に用意し、そのサブクラスとしてRoltoのクラスを作るのが順当な考え方でしょう。でも、Roltoが1台目ですし、後で大きく違うタイプのプリンターを追加することもあり得ます。スーパークラスは2機種目の追加のときに考えれば良いし、余計な作業はやりたくないので、今はスーパークラスを作らないと決めました。今回は、スーパークラスを後で追加しても大丈夫なようにメソッドを用意し、Roltoのクラスだけを作ります。

Roltoを別なプリンターに切り替える話をしましたが、逆のこともいえます。別なアプリでRoltoを使う場合、Roltoのクラスをそのままコピーすれば、それを呼び出すコードだけ書けば済みます。つまり、再利用しやすいコードになるわけです。

 

続いて、印刷内容を作る部分です。オフスクリーンで描画し、その内容をUIImageとして仕上げます。オフスクリーンの描画に関しては、作成から終了までの機能を、独立したクラスとして以前に作りました。どのアプリにでも使えるようになっています。今回も、それを使います。

印刷内容を作るのに使うデータは、そのデータを扱うモデルのクラスに入っています。オフスクリーン描画クラスを使うと、実際に書くコード量は短くなるでしょう。今回は印刷の種類が1つで、わざわざ別クラスに作る必要もないと考え、モデルのクラスに含めることとしました。今後、印刷の種類が増えたら、別クラスに分けるかもしれません。

 

最後に、ユーザーインターフェース(UI)部分です。プリンターのような機器を使う場合は、UIに2つの要素が含まれます。1つは、印刷するデータを選んだり、印刷の形式を選んだりするもので、プリンターに直接関係しない要素です。残りは、プリンターを検索したり、印刷を開始したりとか、プリンターを操作する要素で、プリンターに直接関係するものです。これらが明確に分けて画面に付けられれば良いのですが、実際には混在して作ることになります。

また、プリントする機能は、対象となる内容を表示した画面に付けるのが一般的で、印刷する内容の種類だけ追加することになります。大抵の操作手順は、関係する画面ごとに印刷ボタンを用意して、タップしたら選択画面に切り替わります。現れた画面では、データの選択や、印刷の開始などが行なえます。

難しいのは印刷の途中キャンセルで、キャンセルを可能にするとUIが使いづらくなりがちです。現れた選択画面を消さないままキャンセル可能にしておき、そこに印刷の成否などを表示し、確認できたらユーザー操作で戻るといった形でしょうか。逆にキャンセルが不要なら、印刷開始で元の画面に戻り、印刷の成否は、戻った画面にメッセージを表示するという形も可能です。余計な操作を不要に作れます。

以上のようなことを総合的に検討するのですが、今回は印刷が1種類で、特定の画面上でしか使わないため、そこに多くの機能をつけることとしました。もちろん依頼主と相談し、要望を重視しての結果です。

具体的には、その画面を開いたときにRoltoを自動的に検出して(検出の手間を不要にする配慮)、画面上には、Roltoの状態を表示するボタン(もし接続してなければ、検出から始める)、印刷ダイアログの呼び出しボタンを加えます。ダイアログ内では、印刷対象のデータを選択する機能と、印刷の開始とキャンセルのボタンも付けます。印刷時間が短そうなので、印刷の途中キャンセル機能は付けません。また、Roltoの画質変更機能は、アプリの環境設定画面に付けることとしました。

以上の機能は、それぞれ対象となるクラスに加えます。こちらも、印刷の種類が増えた時点で、新しいクラスを追加するか検討することとしました。

 

全体の構造が固まったので、あとは1つずつ作っていくだけです。まずは、Roltoのクラスからでしょう。

2014年10月22日水曜日

間接参照を幅広く使う

前回は、swiftでUI部品を生成する関数の話をしました。その原点となる考え方を、他の話よりも先に紹介したほうが良いでしょう。その考え方とは「間接参照」です。柔軟性の高いソフトウェアを作る上で、おそらく一番大事な考え方だと思います。仮にオブジェクト指向を知らなくても、間接参照を上手に使えば、柔軟性の高いシステムが作れるほどですから。

 

UI部品を生成する関数ですが、別の視点から見てみましょう。通常、UI部品の生成を、使う箇所にベタで書いた場合、使う箇所とUI部品の生成コード(UI部品クラスのインスタンスを生成するコード)が直接つながっています。しかし、生成関数を使うと、使う箇所は生成関数につながり、生成関数が生成コードとつながります。つまり、使う箇所と生成コードの間に生成関数が挿入され、使う箇所と生成コードが、生成関数を通じて間接参照されていることになります。生成関数とは、間接参照を実現するための方法でもあります。

参照関係の間に関数が入ることと、関数内にソースコードを記述できることにより、単なる参照よりも柔軟な可能性が生まれます。UI部品のデフォルト値をまとめて変更できるだけでなく、新しい機能を加えたりが、関数部分の変更だけで実現できるのです。GUIの設計ツールなども、生成するUI部品を参照してはいますが、まとめて機能を変更することはできません。関数を用いた間接参照だから、可能になるわけです。

 

間接参照は、幅広く利用可能です。もっとも単純な、間接参照の例も挙げてみましょう。よく使う、色の定義です。文字の色、背景の色、枠線の色など、GUIでは必ず設定する属性の1つでしょう。一番ありがちな作り方は、ソースコードの中に、ベタで色を指定する方法です。swiftなら次のように。

labelMessage.textColor = UIColor.redColor()
labelMessage.text = "エラーが発生しました。"

このように作ると、何かの色をまとめて変えたいとき、修正箇所が数多くなってしまいます。さらに、修正箇所がどこにあるのか探すのは大変で、修正漏れが発生しやすくなります。

こんなときも役立つのが、間接参照です。色に名前をつけて定義し、それを参照する形で色を指定します。swiftなら「let」を使って次のようになります。

// どこかで事前に定義
let COLOR_BLACK = UIColor.blackColor()
let COLOR_WHITE = UIColor.whiteColor()
let COLOR_BLUE = UIColor.blueColor()
let COLOR_GREEN = UIColor.greenColor()
let COLOR_RED = UIColor.redColor()
let COLOR_CLEAR = UIColor.clearColor()
// 使う側
labelMessage.textColor = COLOR_RED

実は、このような作り方は悪い例です。色の名前のまま定義するだけでは、色を変更するときに、この定義を使っている箇所を書き直さなければなりません。「COLOR_RED」と書いてたのを、「COLOR_BLUE」に直すといったように。これでは、柔軟性の高い作り方ではありませんよね。

 

もっと賢い作り方があります。色の名前ではなく、色の役割の名前で定義する方法です。たとえば、注意レベルの違いを色分けするとき、次のように定義することができます。

// どこかで事前に定義
let COLOR_NORMAL = UIColor.blackColor()
let COLOR_OK = UIColor.greenColor()
let COLOR_CAUTION = UIColor.blueColor()
let COLOR_ERROR = UIColor.redColor()
// 使う側
labelMessage.textColor = COLOR_ERROR

このように作ると、どうでしょう。エラーの色を赤からオレンジ色に変えたいとき、「COLOR_ERROR」の色指定だけ修正すれば良く、「COLOR_ERROR」を使っている全箇所は触らずに済みます。エラーの色を定義し、それを間接参照する形で作ったからこそ、1カ所の変更で全部を変えられるようになったわけです。色の変更では、APIで用意された色だけでなく、RGB値による色指定も可能です。色の微妙な変更も、修正するのは一カ所だけです。

上記の作り方では、色の名前ではなく、色の使い分けの目的別に定義しています。通常の状態が「NORMAL」、処理成功が「OK」、ちょっとした注意を示すのが「CAUTION」、より重大なエラーを伝えるのが「ERROR」です。これら4つを組み合わせて使うことになります。

 

使い分けの目的別に作ると、同じ色(特に黒色)を何個も定義することになります。それでも構わないどころか、それが普通です。もう1つ、よく使う色の定義を挙げましょう。

let COLOR_SELECTED = UIColor.blueColor()
let COLOR_UNSELECTED = UIColor.blackColor()

名前を見て分かるように、選択状態と非選択状態の色を定義しています。ここの「COLOR_UNSELECTED」も、前述の「COLOR_NORMAL」も、色としては黒を指定していますが、使う目的は異なります。目的が異なるから、同じ色の指定なのに、別々に用意しているわけです。ソースコードの各箇所でどちらを使うのかは、使用する目的に合わせて選びます。

 

選択と非選択の色の定義では、どこに適用するかで使い分けることが重要です。何の選択に使うのかで、別々の名前を定義しておくと、後から何カ所も修正するといった面倒を防止できます。

// 一般的な選択と非選択の色
let COLOR_SELECTED = UIColor.blueColor()
let COLOR_UNSELECTED = UIColor.blackColor()
// 削除する場合の選択と非選択の色
let COLOR_DELETE_SELECTED = UIColor.redColor()
let COLOR_DELETE_UNSELECTED = UIColor.blackColor()

複数の色分けを、どのように使い分けたら良いかは、後々発生しそうな修正を予測しながら考えてみてください。

分ける場合の基本としては、UI部品の生成関数を複数作ったときと同じです。一緒に変わってほしくないものを分けるだけです。たとえ今は同じ値であっても、違う設定に変わりそうだと感じたなら、別々に用意するのが賢い選択でしょう。

 

色の指定は、多くの箇所に現れます。ここでは色の事前定義による作り方を紹介しましたが、すべての色指定を、事前の色定義にすべきとは思いません。前回のUI部品の生成関数のように、その関数自体が間接参照の考え方で作られている場合、その関数内の色しては、事前の色定義を使わなくても構わないでしょう。ただし、何かの目的で別な色と統一したい場合は、生成関数の中でも、事前の色定義を使うことがあります。

 

単純な色指定の話でも、長くなってしまいました。後から色を変えたいというのは、よくある話です。それだけに、今回紹介したような作り方は重要で、無駄な作業を減らしてくれます。

間接参照を使った作り方は、あまりにも有効なので、これから何度も登場すると思います。間接参照という説明が入ってなくても、間接参照の考え方で作られている場合も多いので、間接参照の考え方を頭の奥底にでも入れておくとよいかもです。

2014年10月21日火曜日

UI部品の生成を関数として用意する

設計方針で、Interface Builderもstoryboardも使わないと決めました。大きな理由の1つに、変更に対する柔軟性の確保があります。その実現には、UI部品を生成するための共通処理が必要です。

 

swiftの場合、具体的にはどうするのでしょう。考え方としては、どのUI部品でも、部品を使う側のソースコード上ではなく、別に用意した処理を通して生成することにします。swiftなら、関数が最適でしょう。UIButtonを生成する関数、UILabelを生成する関数など、部品の種類ごとに用意します。具体的にな例としては、つぎのようなコードになります。

func createLabelF(text: String, text_size: CGFloat, align: NSTextAlignment, 
        x: CGFloat, y: CGFloat, width: CGFloat, height: CGFloat) -> UILabel {
    let iLabel: UILabel = UILabel(frame: CGRectMake(x, y, width, height))
    iLabel.backgroundColor = UIColor.clearColor()
    iLabel.text = text
    iLabel.font = UIFont(name: FONT_NAME_DEFAULT, size: text_size)
    iLabel.textColor = UIColor.blackColor()
    iLabel.textAlignment = align
    return iLabel
}
//(注:ここで「FONT_NAME_DEFAULT」は、別に定義した値です)

こうした関数で重要なのは、UI部品ごとのデフォルト設定を入れておくことです。デフォルト設定とは、一番使う設定のことです。決まった設定を全部入れておくことで、生成後に細かく設定する必要がなくなります。逆に、よく設定する項目は、引数に入れておきます。引数に入れておくことで、関数を呼び出した後、別に設定する必要がなくなります。

 

使い方は簡単です。たった1行だけで、UI部品を生成できます。次のように書くだけです。

let labelTitle = createLabelF("日付", 18, ALIGN_LEFT, 690, 320, 45, 25)
//(注:ここで「ALIGN_LEFT」は、別に定義した値です)

もしデフォルトと違う設定で作る場合も簡単です。生成したインスタンスに、必要な変更を加えるだけです。具体的な例は、次のようになります。

let labelTitle = createLabelF("日付", 18, ALIGN_LEFT, 690, 320, 45, 25)
labelTitle.layer.borderWidth = 1
//(注:ここで「ALIGN_LEFT」は、別に定義した値です)

このソースコードには、別な意味も含まれています。このラベルは、デフォルトのラベルとは違う設定で、borderWidthだけが変更されいていると分かるのです。

こうした関数を使わないで作る場合を考えてみてください。全部のソースコードに、ラベル生成をベタで書いた場合です。同じようなソースコードが各所に並んでるだけでなく、どれがデフォルトの設定か、またはデフォルトとはどこが違うのか、ソースコードから読み取るのは非常に困難です。共通の生成関数を作ることは、デフォルトを統一するだけでなく、デフォルトと何が違うのかまで明確にしてくれます。これも大きなメリットです。

 

UI部品ごとの生成関数は、いろいろな場面で使うはずです。ですから、どこからでも呼び出せる形にします。具体的には、1つのswiftソースファイルに集めて、プロジェクトに1個だけ用意します。私の場合は、ファイル名を「zz_base.swift」としてます。ファイル名の最初の3文字が、ソースファイルの分類となります。「zz_」は、プロジェクトで共通につかう機能を意味し、基本となる部品なので「base」としました。

このファイルは、関数を並べただけですから、どのswiftソースファイルからも関数名だけで呼び出せます。そうでないと使いにくいですから、わざとそうしているというわけです。

 

また、この一連の関数は、UI部品を使うアプリなら必ず入れます。1個用意しておくだけで、すべてのアプリで使えるというわけです。一度用意しておけば、ほぼすべてのアプリで共通に使えます。アプリのプロジェクトを生成したら、真っ先に入れるソースファイルとなります。アプリ共通で使えるライブラリと呼んでも良いでしょう。

 

ここからは応用の話です。UI部品ごとに1つの関数を用意するのは基本ですが、絶対に1つとは限りません。ボタンのデザインが2種類必要で、それぞれに別な役割や使いどころがあるとしたら、生成関数を2つ用意するのがベストです。それぞれ別々にデフォルト値を持ち、デフォルト値を変更してもお互いに干渉しません。分けた関数ごとに、デフォルトの変更は簡単ですし、それぞれ独立してデフォルトを変えられるのもメリットとなります。

また、別な拡張の仕方も容易になります。たとえば、特定の種類のボタンには、タップ中に別な表示や動きやをさせるといった場合です。UIButtonのサブクラスを作って、そこに表示や動きを記述します。該当する種類のボタン生成関数では、UIButtonの代わりにサブクラスのボタンを生成し、UIButtonボタンとして返します。このような方法なら、後からでもボタンの機能を容易に追加できます。変更するのは、サブクラスの追加と、ボタン生成関数だけです。ボタン生成を呼び出している側のソースコードを変更する必要はありません。もちろん、呼び出し側をまったく変更せず実現できる機能は限定されますが、変更への柔軟性が高いことは確かです。

 

以上のように、UI部品は必ず関数で生成するように作ると、変更への柔軟性は格段に高まります。また、一度作っておけば、どのアプリにも使い回しできて非常に便利です。UI部品の関数に限らず、このような複数アプリで共通で使えるライブラリが充実すると、まったく新規のアプリ開発でも、最初から3割ぐらい出来上がった状態で始めるのと同じです。

2014年10月20日月曜日

開発方針:Interface Builderもstoryboardも使わない

ブログのタイトルのとおり、Xcode+swiftでiPad上で動く業務アプリを開発しています。その際に気付いたことなどを、いろいろと書いてみます。一部の人には役に立つのではと思ったからです。これは良いと思った考え方やアイデアは、どんどん使ってください。

 

最初に作ったのは、Titanium mobileで作って運用中の業務アプリの移植でした。swiftとiOS APIを覚えるためにと、試しに移植してみることにしたわけです。このアプリでは、よく使われるUI部品(TableViewやWebViewも含む)、画面切り替え、ファイルの読み書き、オフスクリーンの描画、メール送信、ペーストボード、時間管理など、いろいろな要素が含まれていています。これを移植すれば、たいていの業務アプリが作れるようになると考えたからです。

実際、移植が終わった時点では、自分なりのライブラリが残り、これからのアプリ開発に広く役立つ基礎が整いました。また、移植したアプリは実際の業務で使われることとなり、今後はXcodeで開発することになりました。広い意味でも、移植してよかったです。

 

開発で一番大事なのが、設計方針です。設計方針といっても、何種類かの視点がありますが、まずは開発ツールの使い方です。何を使い、何を使わないかを決めなければなりません。xcodeでは、Interface Builderを使うか使わないか、storyboardを使うか使わないか、この2点が重要でしょう。結論としては、どちらも使わないで作ると決めました。

これらのツールを使うと、一見は作りやすく見えます。でも実際には、開発面では柔軟性が低い、つまり変更に弱いアプリに仕上がってしまいます。たとえば、全部のボタンを違う設定に変更したいとき、Interface Builderで個々に呼び出して変更したのでは、大変な手間になります。しかし、ソースコードでボタン生成の共通処理を作っておけば、その1カ所を変更するだけで、全てのボタンを一発で変えられます。このような柔軟性の高い作り方をするためには、できるだけソースコードで書いて作ることが重要なのです。

トラブル対処でも、できるだけソースコードで書いた方が安心です。ツールを使うと、そのツールの使い方が悪かったり、ツールにバグがあったりして、トラブルの原因が見えづらくなりがちです。ソースコードだけならば、原因は自分の作り方にあり、ソースコードだけを調べて原因追及できます。このほうが、はるかに効率的でしょう。

あと業務アプリでは、同じ種類のボタンや項目を、何個も並べることが多くあります。これもfor文で生成しながら配列に入れる処理が良く、ソースコードだけで作る方法に適しています。業務アプリこそ、ツールを使わない作り方に向いているのかもしれません。

 

ツールを使うと、明らかに良い面もあります。それはGUI設計で、最終的な形を見ながら作れる点です。これは捨てがたい魅力なのですが、なくても何とかなります。画面設計は、専用の空アプリを用意して対応します。1画面だけの中身なしアプリで、ソースコードにより部品を並べていきます。軽いアプリのため、シミュレーターを起動するのも短時間で済みます。ソースコードの表示位置や大きさを変更し、シミュレーターを起動して確認する作業を何回か繰り返すだけです。良いと思ったら、ソースコードを目的のアプリへコピーします。

このアプリのおかげで、GUI設計がだいぶ楽になりました。画面ごとにコピーして、必要な画面分だけ作りました。あとで生じるのは微調整だけなので、大きく困ることはありませんでした。

 

のっけから、あまり一般的ではない作り方だと感じたかもしれません。また、ツールを使わずに作るのは大変だと思うかもしれません。でも試してみると、それほど大変ではありませんでした。余計なトラブルに巻き込まれないためにも、柔軟性の高いアプリを作るためにも、Interface Builderやstoryboardを使わない作り方をお薦めします。

今後は、これらのツールを使わないで作るときのコツや、柔軟性の高い設計方法を書いていければと思っています。Titaniumのブログで書いたのと重複する内容でも、気にせずに書きます。こちらに書かないと、検索で見付からないでしょうから。