You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cordova.apache.org by st...@apache.org on 2014/06/05 01:26:14 UTC
[1/2] CB-6127 Spanish and French Translations added. Github close #31
Repository: cordova-plugin-file
Updated Branches:
refs/heads/master 12cb0452b -> 05e393ddb
http://git-wip-us.apache.org/repos/asf/cordova-plugin-file/blob/05e393dd/doc/ja/index.md
----------------------------------------------------------------------
diff --git a/doc/ja/index.md b/doc/ja/index.md
new file mode 100644
index 0000000..42ece5c
--- /dev/null
+++ b/doc/ja/index.md
@@ -0,0 +1,201 @@
+<!---
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+
+# org.apache.cordova.file
+
+このプラグインは、 [HTML5 ファイル システム API][1]を提供します。 使用状況、件名に HTML5 岩 '[ファイルシステムの記事][2]を参照してください。 他のストレージ オプションの概要については、コルドバの[ストレージ ・ ガイド][3]を参照してください。.
+
+ [1]: http://dev.w3.org/2009/dap/file-system/pub/FileSystem/
+ [2]: http://www.html5rocks.com/en/tutorials/file/filesystem/
+ [3]: http://cordova.apache.org/docs/en/edge/cordova_storage_storage.md.html
+
+## インストール
+
+ cordova plugin add org.apache.cordova.file
+
+
+## サポートされているプラットフォーム
+
+* アマゾン火 OS
+* アンドロイド
+* ブラックベリー 10
+* iOS
+* Windows Phone 7 と 8 *
+* Windows 8 *
+* Firefox の OS
+
+**これらのプラットフォームがサポートしていない `FileReader.readAsArrayBuffer` も `FileWriter.write(blob)` .*
+
+## ファイルを保存する場所
+
+V1.2.0、現在重要なファイル システム ディレクトリへの Url を提供しています。 各 URL はフォーム*file:///path/to/spot/*に変換することができます、 `DirectoryEntry` を使用して`window.resolveLocalFileSystemURL()`.
+
+`cordova.file.applicationDirectory`-読み取り専用のディレクトリは、アプリケーションがインストールされています。(*iOS*、*アンドロイド*)
+
+`cordova.file.applicationStorageDirectory`-アプリのプライベートの書き込み可能な記憶域のルートです。(*iOS*、*アンドロイド*)
+
+`cordova.file.dataDirectory`-どこにアプリケーション固有のデータ ファイルを置きます。(*iOS*、*アンドロイド*)
+
+`cordova.file.cacheDirectory`-キャッシュのファイルをアプリケーションの再起動後も維持する必要があります。アプリは、ここでファイルを削除する OS 依存しないでください。(*iOS*、*アンドロイド*)
+
+`cordova.file.externalApplicationStorageDirectory`外部ストレージのアプリケーション領域。(*iOS*、*アンドロイド*)
+
+`cordova.file.externalDataDirectory`-外部ストレージ上のアプリ固有のデータ ファイルを配置する場所。(*アンドロイド*)
+
+`cordova.file.externalCacheDirectory`外部ストレージにアプリケーション キャッシュ。(*アンドロイド*)
+
+`cordova.file.externalRootDirectory`-外部ストレージ (SD カード) ルート。(*アンドロイド*)
+
+`cordova.file.tempDirectory`-OS をクリアすることができます temp ディレクトリが。(*iOS*)
+
+`cordova.file.syncedDataDirectory`-(例えば iCloud) に同期する必要がありますアプリケーション固有のファイルを保持します。(*iOS*)
+
+`cordova.file.documentsDirectory`-ファイル、アプリがプライベート他行われなくなります (Office ファイルなど) には意味が。(*iOS*)
+
+## Android の癖
+
+### Android の永続的なストレージの場所
+
+Android のデバイスに永続的なファイルを格納する複数の有効な場所があります。 さまざまな可能性について広範な議論のための[このページ][4]を参照してください。
+
+ [4]: http://developer.android.com/guide/topics/data/data-storage.html
+
+以前のバージョンのプラグインは、デバイスの SD カード (または同等のストレージ パーティション) マウントされていたと主張したかどうかに基づいて、起動時に一時と永続的なファイルの場所を選ぶでしょう。 SD カードがマウントされている場合、または大規模な内部ストレージ パーティションが利用可能な場合 (ようネクサス デバイス上) し、永続的なファイルは、その領域のルートに格納されます。 これはすべての Cordova アプリ見ることができる利用可能なファイルのすべてのカードに意味しました。
+
+SD カードが利用できない場合、以前のバージョン取得データを保存/データ/データの下<packageid>、アプリ、互いからの分離がまだユーザー間で共有するデータを引き起こす可能性があります。
+
+内部ファイルの保存場所やアプリケーションの config.xml ファイルに優先順位を持つ以前のロジックを使用してファイルを保存するかどうかを選択することが可能です今。 これを行うに、config.xml に次の 2 行のいずれかを追加します。
+
+ <preference name="AndroidPersistentFileLocation" value="Internal" />
+
+ <preference name="AndroidPersistentFileLocation" value="Compatibility" />
+
+
+この行がなければファイル プラグインは既定値として「互換性」を使用します。優先タグが存在し、これらの値の 1 つではない場合、アプリケーションは起動しません。
+
+アプリケーションは、ユーザーに以前出荷されている場合、古い (前 1.0) を使用して、このプラグインのバージョンし、永続的なファイルシステムに保存されているファイルには「互換性」を設定する必要があります。 自分のアプリケーションをアップグレードする既存のユーザーを彼らの装置によって、以前に保存されたファイルにアクセスすることができることがあることを意味する「内部」に場所をスイッチングします。
+
+アプリケーション場合は、新しい、または永続的なファイルシステムにファイルが格納され以前は決して、「内部」の設定は推奨一般に。
+
+## iOS の癖
+
+* `FileReader.readAsText(blob, encoding)`
+ * `encoding`パラメーターはサポートされていませんし、utf-8 エンコーディングが常に有効です。
+
+### iOS の永続的なストレージの場所
+
+IOS デバイスに永続的なファイルを格納する 2 つの有効な場所がある: ドキュメントとライブラリのディレクトリ。 プラグインの以前のバージョンは、唯一のこれまでドキュメント ディレクトリに永続的なファイルを格納されます。 これは、ディレクトリの目的は、輸出のための完全なドキュメントを作成するのではなくなかったがしばしば意図されていたり、特に多数の小さいファイルを処理するアプリケーションの場合、iTunes に表示されているすべてのアプリケーションのファイルを作るの副作用があった。
+
+ドキュメントまたはアプリケーションの config.xml ファイルに優先順位のライブラリ ディレクトリにファイルを保存するかどうかを選択することが可能です今。 これを行うに、config.xml に次の 2 行のいずれかを追加します。
+
+ <preference name="iosPersistentFileLocation" value="Library" />
+
+ <preference name="iosPersistentFileLocation" value="Compatibility" />
+
+
+この行がなければファイル プラグインは既定値として「互換性」を使用します。優先タグが存在し、これらの値の 1 つではない場合、アプリケーションは起動しません。
+
+アプリケーションは、ユーザーに以前出荷されている場合、古い (前 1.0) を使用して、このプラグインのバージョンし、永続的なファイルシステムに保存されているファイルには「互換性」を設定する必要があります。 自分のアプリケーションをアップグレードする既存のユーザーを以前に保存されたファイルにアクセスすることができるだろうことを意味する「ライブラリ」に場所をスイッチングします。
+
+アプリケーション場合は、新しい、または永続的なファイルシステムにファイルが格納され以前は決して、「ライブラリ」設定は推奨一般に。
+
+### Firefox OS 癖
+
+ファイル システム API Firefox OS でネイティブ サポートされていないと、indexedDB の上にシムとして実装されています。
+
+* 空でないディレクトリを削除するときに失敗しません
+* ディレクトリのメタデータをサポートしていません
+* サポートしていない `requestAllFileSystems` と `resolveLocalFileSystemURI` 方法
+* 方法 `copyTo` と `moveTo` ディレクトリをサポートしていません
+
+## ノートをアップグレードします。
+
+このプラグインのデベロッパーで、 `FileEntry` と `DirectoryEntry` 構造変更、公開された仕様に沿ったより多くであります。
+
+プラグインの前 (pre 1.0.0) バージョン、デバイス-絶対-ファイルの場所に格納されている、 `fullPath` のプロパティ `Entry` オブジェクト。これらのパスはようになります通常
+
+ /var/mobile/Applications/<application UUID>/Documents/path/to/file (iOS)
+ /storage/emulated/0/path/to/file (Android)
+
+
+これらのパスはまたによって返された、 `toURL()` 法、 `Entry` オブジェクト。
+
+デベロッパーと、 `fullPath` 属性は、 *HTML のファイルシステムのルートに対する相対パス*のファイルへのパス。 したがって、上記のパスは両方によって表される今、 `FileEntry` オブジェクトが、 `fullPath` の
+
+ /path/to/file
+
+
+場合は、アプリケーションはデバイス絶対パスで動作し、以前からそれらのパスを取得、 `fullPath` のプロパティ `Entry` を使用してコードを更新する必要があり、オブジェクト `entry.toURL()` 代わりに。
+
+後方の互換性、 `resolveLocalFileSystemURL()` メソッドはデバイス絶対パスを受け入れるし、戻ります、 `Entry` 、一時的または永続的なファイル ・ システム内でそのファイルが存在する限り、それに対応するオブジェクト。
+
+これは特に以前デバイス絶対パスを使用してファイル転送のプラグインで問題となっている (そしてまだそれらを受け入れることができます)。 ので交換、ファイルシステムの Url で正しく動作するように更新されている `entry.fullPath` と `entry.toURL()` デバイス上のファイルで動作するプラグインを得て問題を解決する必要があります。
+
+V1.1.0 戻り値での `toURL()` が変更された (\[CB-6394\] (https://issues.apache.org/jira/browse/CB-6394) を参照) を絶対的な 'file://' で始まる URL を返します。 可能な限り。 確保するために、' cdvfile:'-使用することができます URL `toInternalURL()` 今。 このメソッドは、フォームのファイルシステムの Url を返します今
+
+ cdvfile://localhost/persistent/path/to/file
+
+
+これはファイルを一意に識別するために使用できます。
+
+## エラー コードと意味のリスト
+
+エラーがスローされると、次のコードのいずれかが使用されます。
+
+* 1 = NOT\_FOUND\_ERR
+* 2 = SECURITY_ERR
+* 3 = ABORT_ERR
+* 4 = NOT\_READABLE\_ERR
+* 5 = ENCODING_ERR
+* 6 = NO\_MODIFICATION\_ALLOWED_ERR
+* 7 = INVALID\_STATE\_ERR
+* 8 = SYNTAX_ERR
+* 9 = INVALID\_MODIFICATION\_ERR
+* 10 = QUOTA\_EXCEEDED\_ERR
+* 11 = TYPE\_MISMATCH\_ERR
+* 12 = PATH\_EXISTS\_ERR
+
+## (省略可能) プラグインを構成します。
+
+利用可能なファイルシステムのセットは構成されたプラットフォームをすることができます。IOS と Android の両方を認識します。 <preference> タグの `config.xml` をインストールするファイルシステムの名前します。既定では、すべてのファイル システムのルートが有効になります。
+
+ <preference name="iosExtraFilesystems" value="library,library-nosync,documents,documents-nosync,cache,bundle,root" />
+ <preference name="AndroidExtraFilesystems" value="files,files-external,documents,sdcard,cache,cache-external,root" />
+
+
+### アンドロイド
+
+* ファイル: アプリケーションの内部ファイルのストレージ ディレクトリ
+* 外部ファイル: アプリケーションの外部のファイルのストレージ ディレクトリ
+* sd カード:、グローバル外部ストレージ ディレクトリをファイル (これは SD カードのルートがインストールされている場合)。 必要があります、 `android.permission.WRITE_EXTERNAL_STORAGE` これを使用するアクセス許可。
+* キャッシュ: アプリケーションの内部キャッシュ ディレクトリ
+* キャッシュ外部: 外部キャッシュのアプリケーションのディレクトリ
+* ルート: デバイス全体のファイルシステム
+
+アンドロイドを「ファイル」ファイルシステム内の"ドキュメント/"サブディレクトリを表す"ドキュメント"という名前の特殊なファイルシステムもサポートしています。
+
+### iOS
+
+* ライブラリ: ライブラリのアプリケーションのディレクトリ
+* ドキュメント: ドキュメントのアプリケーションのディレクトリ
+* キャッシュ: キャッシュのアプリケーションのディレクトリ
+* バンドル: アプリケーションバンドル;アプリ自体 (読み取りのみ) ディスク上の場所
+* ルート: デバイス全体のファイルシステム
+
+既定では、ライブラリとドキュメント ディレクトリを iCloud に同期できます。 ライブラリまたはドキュメントのファイルシステム内の特別な非同期ディレクトリを表す 2 つの追加のファイルシステム、"ライブラリ nosync"、「ドキュメント nosync」を要求することもできます。
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-plugin-file/blob/05e393dd/doc/ja/plugins.md
----------------------------------------------------------------------
diff --git a/doc/ja/plugins.md b/doc/ja/plugins.md
new file mode 100644
index 0000000..3dedb28
--- /dev/null
+++ b/doc/ja/plugins.md
@@ -0,0 +1,124 @@
+<!---
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+
+# プラグイン開発者のためのノート
+
+これらのノートは、主に人造人間と iOS 開発者向けファイルのプラグインを使用して、ファイル システムでプラグインのインターフェイスを記述するもの。
+
+## コルドバのファイル システムの Url の操作
+
+バージョン 1.0.0 以降このプラグインが使用した Url とは `cdvfile` raw デバイス ファイル システム パスを JavaScript に公開するのではなく、ブリッジ上のすべての通信方式します。
+
+JavaScript 側認証と DirectoryEntry オブジェクトの HTML ファイル システムのルートからの相対である fullPath 属性があることを意味します。 呼び出す必要がありますプラグインの JavaScript API は、認証または DirectoryEntry オブジェクトを受け入れる場合 `.toURL()` 、橋を渡ってネイティブ コードに渡す前に、そのオブジェクト。
+
+### Cdvfile を変換する://fileystem のパスに Url
+
+ファイルシステムへの書き込みする必要があるプラグインは実際のファイルシステムの場所に受信ファイル用の URL を変換したい可能性があります。ネイティブのプラットフォームによって、これを行うための複数の方法があります。
+
+覚えておくことが重要ですすべてではない `cdvfile://` の Url はデバイス上の実際のファイルをマッピング可能な。 いくつかの Url は、ファイルでは表されないまたはリモートのリソースを参照することができますもをデバイス上の資産を参照できます。 プラグインはこれらの可能性のために彼らの Url パスに変換するしようとしているときに戻って、有意義な結果を得るかどうか常にテスト必要があります。
+
+#### アンドロイド
+
+Android 上で変換する最も簡単な方法は `cdvfile://` を使用してファイルシステムのパスに URL が `org.apache.cordova.CordovaResourceApi` 。 `CordovaResourceApi`扱うことができるいくつかの方法があります `cdvfile://` Url:
+
+ // webView is a member of the Plugin class
+ CordovaResourceApi resourceApi = webView.getResourceApi();
+
+ // Obtain a file:/// URL representing this file on the device,
+ // or the same URL unchanged if it cannot be mapped to a file
+ Uri fileURL = resourceApi.remapUri(Uri.parse(cdvfileURL));
+
+
+また、ファイル プラグインを直接使用することが可能です。
+
+ import org.apache.cordova.file.FileUtils;
+ import org.apache.cordova.file.FileSystem;
+ import java.net.MalformedURLException;
+
+ // Get the File plugin from the plugin manager
+ FileUtils filePlugin = (FileUtils)webView.pluginManager.getPlugin("File");
+
+ // Given a URL, get a path for it
+ try {
+ String path = filePlugin.filesystemPathForURL(cdvfileURL);
+ } catch (MalformedURLException e) {
+ // The filesystem url wasn't recognized
+ }
+
+
+パスから変換する、 `cdvfile://` の URL:
+
+ import org.apache.cordova.file.LocalFilesystemURL;
+
+ // Get a LocalFilesystemURL object for a device path,
+ // or null if it cannot be represented as a cdvfile URL.
+ LocalFilesystemURL url = filePlugin.filesystemURLforLocalPath(path);
+ // Get the string representation of the URL object
+ String cdvfileURL = url.toString();
+
+
+あなたのプラグインは、ファイルを作成し、認証オブジェクトを返す場合ファイルのプラグインを使用:
+
+ // Return a JSON structure suitable for returning to JavaScript,
+ // or null if this file is not representable as a cdvfile URL.
+ JSONObject entry = filePlugin.getEntryForFile(file);
+
+
+#### iOS
+
+IOS にコルドバと同じ使用しない `CordovaResourceApi` アンドロイドとして概念。IOS、上ファイル プラグインを使用して Url をファイルシステムのパスに変換する必要があります。
+
+ // Get a CDVFilesystem URL object from a URL string
+ CDVFilesystemURL* url = [CDVFilesystemURL fileSystemURLWithString:cdvfileURL];
+ // Get a path for the URL object, or nil if it cannot be mapped to a file
+ NSString* path = [filePlugin filesystemPathForURL:url];
+
+
+ // Get a CDVFilesystem URL object for a device path, or
+ // nil if it cannot be represented as a cdvfile URL.
+ CDVFilesystemURL* url = [filePlugin fileSystemURLforLocalPath:path];
+ // Get the string representation of the URL object
+ NSString* cdvfileURL = [url absoluteString];
+
+
+あなたのプラグインは、ファイルを作成し、認証オブジェクトを返す場合ファイルのプラグインを使用:
+
+ // Get a CDVFilesystem URL object for a device path, or
+ // nil if it cannot be represented as a cdvfile URL.
+ CDVFilesystemURL* url = [filePlugin fileSystemURLforLocalPath:path];
+ // Get a structure to return to JavaScript
+ NSDictionary* entry = [filePlugin makeEntryForLocalURL:url]
+
+
+#### Java スクリプトの設定
+
+Java スクリプトの設定を取得するには `cdvfile://` 認証または DirectoryEntry オブジェクトから URL を単に呼び出す `.toURL()` に:
+
+ var cdvfileURL = entry.toURL();
+
+
+プラグインハンドラーの応答で返された FileEntry 構造体の実際のエントリ オブジェクトを変換するハンドラーのコードする必要がありますファイル プラグインをインポートし、新しいオブジェクトを作成します。
+
+ // create appropriate Entry object
+ var entry;
+ if (entryStruct.isDirectory) {
+ entry = new DirectoryEntry(entryStruct.name, entryStruct.fullPath, new FileSystem(entryStruct.filesystemName));
+ } else {
+ entry = new FileEntry(entryStruct.name, entryStruct.fullPath, new FileSystem(entryStruct.filesystemName));
+ }
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-plugin-file/blob/05e393dd/doc/ko/index.md
----------------------------------------------------------------------
diff --git a/doc/ko/index.md b/doc/ko/index.md
new file mode 100644
index 0000000..0c61841
--- /dev/null
+++ b/doc/ko/index.md
@@ -0,0 +1,201 @@
+<!---
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+
+# org.apache.cordova.file
+
+이 플러그인 [HTML5 파일 시스템 API][1]를 제공합니다. 사용에 대 한 주제에 HTML5 바위 ' [파일 시스템 문서][2] 를 참조 하십시오. 다른 저장소 옵션에 대 한 개요, 코르도바의 [저장소 가이드][3] 를 참조합니다.
+
+ [1]: http://dev.w3.org/2009/dap/file-system/pub/FileSystem/
+ [2]: http://www.html5rocks.com/en/tutorials/file/filesystem/
+ [3]: http://cordova.apache.org/docs/en/edge/cordova_storage_storage.md.html
+
+## 설치
+
+ cordova plugin add org.apache.cordova.file
+
+
+## 지원 되는 플랫폼
+
+* 아마존 화재 운영 체제
+* 안 드 로이드
+* 블랙베리 10
+* iOS
+* Windows Phone 7과 8 *
+* 윈도우 8 *
+* Firefox 운영 체제
+
+* *가이 플랫폼을 지원 하지 않는 `FileReader.readAsArrayBuffer` 이나 `FileWriter.write(blob)` .*
+
+## 파일을 저장할 위치를
+
+V1.2.0, 현재 중요 한 파일 시스템 디렉터리에 Url도 제공 됩니다. 각 URL 형태 *file:///path/to/spot/*이며 변환할 수는 `DirectoryEntry` 를 사용 하 여`window.resolveLocalFileSystemURL()`.
+
+`cordova.file.applicationDirectory`-읽기 전용 디렉터리는 응용 프로그램을 설치 합니다. (*iOS*, *안 드 로이드*)
+
+`cordova.file.applicationStorageDirectory`-애플 리 케이 션의 개인 쓰기 가능한 저장소의 루트입니다. (*iOS*, *안 드 로이드*)
+
+`cordova.file.dataDirectory`-응용 프로그램-특정 데이터 파일을 넣어 어디. (*iOS*, *안 드 로이드*)
+
+`cordova.file.cacheDirectory`-캐시 응용 프로그램 다시 시작 해야 하는 파일. 애플 리 케이 션은 여기에 파일을 삭제 하려면 운영 체제에 의존 하지 말아야. (*iOS*, *안 드 로이드*)
+
+`cordova.file.externalApplicationStorageDirectory`-응용 프로그램 외부 저장 공간입니다. (*iOS*, *안 드 로이드*)
+
+`cordova.file.externalDataDirectory`-외부 저장소에 응용 프로그램 특정 데이터 파일을 넣어 어디. (*안 드 로이드*)
+
+`cordova.file.externalCacheDirectory`외부 저장소에 응용 프로그램 캐시입니다. (*안 드 로이드*)
+
+`cordova.file.externalRootDirectory`-외부 저장 (SD 카드) 루트입니다. (*안 드 로이드*)
+
+`cordova.file.tempDirectory`-운영 체제에서 지울 수 있습니다 임시 디렉터리 것입니다. (*iOS*)
+
+`cordova.file.syncedDataDirectory`-(ICloud)를 예를 들어 동기화 해야 하는 응용 프로그램 관련 파일을 보유 하 고 있습니다. (*iOS*)
+
+`cordova.file.documentsDirectory`-애플 리 케이 션, 하지만 그 개인 파일은 다른 applciations (예를 들어 Office 파일)을 의미. (*iOS*)
+
+## 안 드 로이드 단점
+
+### 안 드 로이드 영구 저장 위치
+
+안 드 로이드 장치에 영구 파일을 저장할 여러 유효한 위치가 있다. 다양 한 가능성의 광범위 한 토론에 대 한 [이 페이지][4] 를 참조 하십시오.
+
+ [4]: http://developer.android.com/guide/topics/data/data-storage.html
+
+플러그인의 이전 버전을 시작할 때, 장치는 SD 카드 (또는 해당 스토리지 파티션) 탑재 했다 주장 하는 여부에 따라 임시 및 영구 파일의 위치를 선택 합니다. SD 카드 마운트, 또는 큰 내부 스토리지 파티션에 사용할 수 있었습니다 (같은 넥서스 장치에) 그 후에 영구 파일 공간의 루트에 저장 됩니다. 이 모든 코르 도우 바 애플 리 케이 션 카드에 모두 사용할 수 있는 파일을 볼 수 있는 의미 합니다.
+
+SD 카드 사용할 수 있었다면, 이전 버전에서 /data/데이터/데이터 저장 것이<packageid>서로 다른 애플 리 케이 션을 분리 하지만 사용자 간에 공유할 데이터를 일으킬 수 있습니다.
+
+그것은 지금 내부 파일 저장 위치 또는 응용 프로그램의 config.xml 파일에 기본 설정으로 이전 논리를 사용 하 여 파일을 저장할 것인지를 선택할 수 있습니다. 이렇게 하려면 config.xml에이 두 줄 중 하나를 추가:
+
+ <preference name="AndroidPersistentFileLocation" value="Internal" />
+
+ <preference name="AndroidPersistentFileLocation" value="Compatibility" />
+
+
+이 줄이 없으면 파일 플러그인은 기본적으로 "호환성"을 사용 합니다. 기본 태그,이 이러한 값 중 하나가 아닌 경우에 응용 프로그램이 시작 되지 않습니다.
+
+이전 (사전 1.0)을 사용 하는 경우 응용 프로그램 사용자에 게 발송 되었다 이전,이 플러그인의 버전 영구 파일 시스템에 저장 된 파일에는 다음 "호환성" 특혜를 설정 해야 합니다. "내부"의 위치 전환 그들의 응용 프로그램을 업그레이드 기존 사용자의 그들의 장치에 따라 그들의 이전에 저장 된 파일에 액세스할 수 수 있다는 뜻입니다.
+
+경우 응용 프로그램은 새로운, 또는 이전 영구 파일 시스템에서 파일 저장, "내부" 설정은 일반적으로 권장 됩니다.
+
+## iOS 단점
+
+* `FileReader.readAsText(blob, encoding)`
+ * `encoding`매개 변수는 지원 되지 않습니다, 및 효과에 항상 u t F-8 인코딩을 합니다.
+
+### iOS 영구 저장소 위치
+
+IOS 디바이스에 영구 파일을 저장할 두 개의 유효한 위치가 있다: 문서 디렉터리 및 라이브러리 디렉터리. 플러그인의 이전 버전은 오직 문서 디렉토리에 영구 파일을 저장. 이 부작용 보다는 아니었다 수시로 특히 많은 작은 파일을 처리 하는 응용 프로그램에 대 한 의도, iTunes에 표시 모든 응용 프로그램 파일을 만드는 디렉터리의 용도 내보내기에 대 한 완전 한 문서를 생산 했다.
+
+그것은 지금 문서 또는 응용 프로그램의 config.xml 파일에 기본 설정으로 라이브러리 디렉토리에 파일을 저장할 것인지를 선택할 수 있습니다. 이렇게 하려면 config.xml에이 두 줄 중 하나를 추가:
+
+ <preference name="iosPersistentFileLocation" value="Library" />
+
+ <preference name="iosPersistentFileLocation" value="Compatibility" />
+
+
+이 줄이 없으면 파일 플러그인은 기본적으로 "호환성"을 사용 합니다. 기본 태그,이 이러한 값 중 하나가 아닌 경우에 응용 프로그램이 시작 되지 않습니다.
+
+이전 (사전 1.0)을 사용 하는 경우 응용 프로그램 사용자에 게 발송 되었다 이전,이 플러그인의 버전 영구 파일 시스템에 저장 된 파일에는 다음 "호환성" 특혜를 설정 해야 합니다. "라이브러리" 위치 전환 기존 사용자에 게 응용 프로그램을 업그레이 드의 그들의 이전에 저장 된 파일에 액세스할 수 것을 의미할 것입니다.
+
+경우 응용 프로그램은 새로운, 또는 이전 영구 파일 시스템에서 파일 저장, "도서관" 설정은 일반적으로 권장 됩니다.
+
+### 파이어 폭스 OS 단점
+
+파일 시스템 API Firefox 운영 체제에서 기본적으로 지원 하지 및 indexedDB 위에 심으로 구현 됩니다.
+
+* 비어 있지 않은 디렉터리를 제거할 때 실패 하지 않습니다.
+* 디렉터리에 대 한 메타 데이터를 지원 하지 않습니다.
+* 지원 하지 않는 `requestAllFileSystems` 및 `resolveLocalFileSystemURI` 메서드
+* 메서드 `copyTo` 및 `moveTo` 디렉터리를 지원 하지 않습니다
+
+## 업그레이드 노트
+
+이 플러그인의 v1.0.0에는 `FileEntry` 와 `DirectoryEntry` 구조 변경, 게시 된 사양에 맞춰 더 많은 것.
+
+플러그인의 이전 (pre-1.0.0) 버전 저장 장치-절대--있는 파일 위치는 `fullPath` 속성의 `Entry` 개체. 이러한 경로 일반적으로 같습니다.
+
+ /var/mobile/Applications/<application UUID>/Documents/path/to/file (iOS)
+ /storage/emulated/0/path/to/file (Android)
+
+
+이러한 경로 또한 반환한 했다는 `toURL()` 의 메서드는 `Entry` 개체.
+
+V1.0.0와 `fullPath` 특성은 *HTML 파일 시스템의 루트에 상대적인*파일의 경로를. 그래서, 위의 경로 지금 둘 다에 의해 대표 될 것 이라고는 `FileEntry` 개체는 `fullPath` 의
+
+ /path/to/file
+
+
+장치 절대 경로, 응용 프로그램 작동 하 고 이전을 통해 그 경로 검색 하는 경우는 `fullPath` 속성의 `Entry` 개체를 사용 하 여 코드를 업데이트 해야 하는 다음 `entry.toURL()` 대신.
+
+대 한 뒤 호환성는 `resolveLocalFileSystemURL()` 장치-절대-경로, 수락할 메서드와 반환 합니다는 `Entry` 파일을 임시 또는 영구 파일 시스템 내에서 존재 하는 경우, 해당 개체.
+
+이 특히 이전 장치 절대 경로 사용 하는 파일 전송 플러그인에 문제가 있다 (그리고 아직도 그들을 받아들일 수.) 파일 시스템 Url, 그래서 대체 올바르게 작동 하도록 업데이 트 되었습니다 `entry.fullPath` 함께 `entry.toURL()` 장치에 파일을 사용 하는 플러그인을 지 고 문제를 해결 해야 합니다.
+
+V1.1.0 반환 값에서에서의 `toURL()` 변경 되었습니다 (\[CB-6394\] (https://issues.apache.org/jira/browse/CB-6394) 참조)는 'file://' 절대 URL을 반환 합니다. 가능 하다 면. 보장 하는 ' cdvfile:'-URL을 사용할 수 있습니다 `toInternalURL()` 지금. 이 메서드 이제 양식의 파일 Url을 반환 합니다.
+
+ cdvfile://localhost/persistent/path/to/file
+
+
+어떤 파일을 고유 하 게 식별 하려면 사용할 수 있습니다.
+
+## 오류 코드 및 의미의 목록
+
+오류가 throw 됩니다 때 다음 코드 중 하나가 사용 됩니다.
+
+* 1 = NOT\_FOUND\_ERR
+* 2 = SECURITY_ERR
+* 3 = ABORT_ERR
+* 4 = NOT\_READABLE\_ERR
+* 5 = ENCODING_ERR
+* 6 = NO\_MODIFICATION\_ALLOWED_ERR
+* 7 = INVALID\_STATE\_ERR
+* 8 = SYNTAX_ERR
+* 9 = INVALID\_MODIFICATION\_ERR
+* 10 = QUOTA\_EXCEEDED\_ERR
+* 11 = TYPE\_MISMATCH\_ERR
+* 12 = PATH\_EXISTS\_ERR
+
+## (선택 사항) 플러그인 구성
+
+사용 가능한 파일 시스템의 집합 플랫폼 당 구성된 될 수 있습니다. IOS와 안 드 로이드를 인식 한 <preference> 태그에 대 한 `config.xml` 는 설치 될 파일 시스템의 이름. 기본적으로 모든 파일 시스템 루트 사용할 수 있습니다.
+
+ <preference name="iosExtraFilesystems" value="library,library-nosync,documents,documents-nosync,cache,bundle,root" />
+ <preference name="AndroidExtraFilesystems" value="files,files-external,documents,sdcard,cache,cache-external,root" />
+
+
+### 안 드 로이드
+
+* 파일: 응용 프로그램의 내부 파일 저장 디렉토리
+* 파일 외부: 응용 프로그램의 외부 파일 저장 디렉토리
+* sdcard: 글로벌 외부 파일 저장 디렉토리 (이것은 SD 카드의 루트 설치 된 경우). 가지고 있어야 합니다는 `android.permission.WRITE_EXTERNAL_STORAGE` 이 사용 하는 허가.
+* 캐시: 응용 프로그램의 내부 캐시 디렉터리
+* 캐시 외부: 응용 프로그램의 외부 캐시 디렉터리
+* 루트: 전체 장치 파일 시스템
+
+안 드 로이드는 또한 "파일" 파일 시스템 내에서 "/ 문서 /" 하위 디렉토리를 나타내는 "문서" 라는 특별 한 파일을 지원 합니다.
+
+### iOS
+
+* 라이브러리: 응용 프로그램의 라이브러리 디렉터리
+* 문서: 응용 프로그램의 문서 디렉토리
+* 캐시: 응용 프로그램의 캐시 디렉터리
+* 번들: 응용 프로그램의 번들; (읽기 전용) 디스크에 응용 프로그램 자체의 위치
+* 루트: 전체 장치 파일 시스템
+
+기본적으로 라이브러리 및 문서 디렉토리 iCloud에 동기화 할 수 있습니다. 2 개의 추가적인 파일 시스템, "도서관 nosync" 및 "문서 nosync" 라이브러리 또는 문서 파일 시스템 내에서 특별 한 비 동기화 디렉터리를 대표 하는 요청할 수 있습니다.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-plugin-file/blob/05e393dd/doc/ko/plugins.md
----------------------------------------------------------------------
diff --git a/doc/ko/plugins.md b/doc/ko/plugins.md
new file mode 100644
index 0000000..d5ec121
--- /dev/null
+++ b/doc/ko/plugins.md
@@ -0,0 +1,124 @@
+<!---
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+
+# 플러그인 개발자를 위한 노트
+
+이 노트는 주로 파일 플러그인을 사용 하 여 파일 시스템 플러그인 인터페이스를 작성 하 고 싶은 안 드 로이드와 iOS 개발자를 위한 것입니다.
+
+## 코르 도우 바 파일 시스템 Url 작업
+
+버전 1.0.0, 이후이 플러그인과 Url 사용은 `cdvfile` 교량, 모든 통신 체계 보다는 자바 원시 장치 파일 시스템 경로 노출.
+
+자바 스크립트 측면에서 즉, FileEntry 및 DirectoryEntry 개체 fullPath 속성을 HTML 파일 시스템의 루트에 상대적입니다. FileEntry 또는 DirectoryEntry 개체를 수락 하는 플러그인의 자바 API를 호출 해야 `.toURL()` 다리에 걸쳐 네이티브 코드에 전달 하기 전에 해당 개체에.
+
+### Cdvfile 변환: / / fileystem 경로 Url
+
+플러그인 파일 시스템을 작성 하는 실제 파일 시스템 위치에 받은 파일 시스템 URL을 변환 할 수 있습니다. 이렇게, 네이티브 플랫폼에 따라 여러 방법이 있다.
+
+기억 하는 것이 중요 하다 모든 `cdvfile://` Url은 장치에 실제 파일을 매핑. 일부 Url 파일에 의해 표현 되지 않는 또는 심지어 원격 리소스를 참조할 수 있는 장치에 자산을 참조할 수 있습니다. 이러한 가능성 때문에 플러그인 경로를 Url을 변환 하려고 할 때 다시 의미 있는 결과 얻을 지 여부를 항상 테스트 해야 합니다.
+
+#### 안 드 로이드
+
+안 드 로이드, 변환 하는 간단한 방법에는 `cdvfile://` URL을 파일 시스템 경로 사용 하는 `org.apache.cordova.CordovaResourceApi` . `CordovaResourceApi`처리할 수 있는 여러 가지 방법에는 `cdvfile://` Url:
+
+ // webView is a member of the Plugin class
+ CordovaResourceApi resourceApi = webView.getResourceApi();
+
+ // Obtain a file:/// URL representing this file on the device,
+ // or the same URL unchanged if it cannot be mapped to a file
+ Uri fileURL = resourceApi.remapUri(Uri.parse(cdvfileURL));
+
+
+그것은 또한 파일 플러그인을 직접 사용할 수 있습니다:
+
+ import org.apache.cordova.file.FileUtils;
+ import org.apache.cordova.file.FileSystem;
+ import java.net.MalformedURLException;
+
+ // Get the File plugin from the plugin manager
+ FileUtils filePlugin = (FileUtils)webView.pluginManager.getPlugin("File");
+
+ // Given a URL, get a path for it
+ try {
+ String path = filePlugin.filesystemPathForURL(cdvfileURL);
+ } catch (MalformedURLException e) {
+ // The filesystem url wasn't recognized
+ }
+
+
+경로를 변환 하는 `cdvfile://` URL:
+
+ import org.apache.cordova.file.LocalFilesystemURL;
+
+ // Get a LocalFilesystemURL object for a device path,
+ // or null if it cannot be represented as a cdvfile URL.
+ LocalFilesystemURL url = filePlugin.filesystemURLforLocalPath(path);
+ // Get the string representation of the URL object
+ String cdvfileURL = url.toString();
+
+
+플러그인 파일을 만들고 그것에 대 한 FileEntry 개체를 반환 하려면, 파일 플러그인을 사용.
+
+ // Return a JSON structure suitable for returning to JavaScript,
+ // or null if this file is not representable as a cdvfile URL.
+ JSONObject entry = filePlugin.getEntryForFile(file);
+
+
+#### iOS
+
+IOS에서 코르도바 같은 사용 하지 않는 `CordovaResourceApi` 안 드 로이드 개념. Ios, Url 및 파일 시스템 경로 사이의 변환할 파일 플러그인을 사용 해야 합니다.
+
+ // Get a CDVFilesystem URL object from a URL string
+ CDVFilesystemURL* url = [CDVFilesystemURL fileSystemURLWithString:cdvfileURL];
+ // Get a path for the URL object, or nil if it cannot be mapped to a file
+ NSString* path = [filePlugin filesystemPathForURL:url];
+
+
+ // Get a CDVFilesystem URL object for a device path, or
+ // nil if it cannot be represented as a cdvfile URL.
+ CDVFilesystemURL* url = [filePlugin fileSystemURLforLocalPath:path];
+ // Get the string representation of the URL object
+ NSString* cdvfileURL = [url absoluteString];
+
+
+플러그인 파일을 만들고 그것에 대 한 FileEntry 개체를 반환 하려면, 파일 플러그인을 사용.
+
+ // Get a CDVFilesystem URL object for a device path, or
+ // nil if it cannot be represented as a cdvfile URL.
+ CDVFilesystemURL* url = [filePlugin fileSystemURLforLocalPath:path];
+ // Get a structure to return to JavaScript
+ NSDictionary* entry = [filePlugin makeEntryForLocalURL:url]
+
+
+#### 자바 스크립트
+
+자바 스크립트에서는 `cdvfile://` FileEntry 또는 DirectoryEntry 개체에서 URL를 호출 하면 `.toURL()` 그것에:
+
+ var cdvfileURL = entry.toURL();
+
+
+플러그인 응답 처리기에서 반환 된 FileEntry 구조에서 실제 항목 개체 변환 하려면 처리기 코드 해야 파일 플러그인 가져오고 새 개체를 만들:
+
+ // create appropriate Entry object
+ var entry;
+ if (entryStruct.isDirectory) {
+ entry = new DirectoryEntry(entryStruct.name, entryStruct.fullPath, new FileSystem(entryStruct.filesystemName));
+ } else {
+ entry = new FileEntry(entryStruct.name, entryStruct.fullPath, new FileSystem(entryStruct.filesystemName));
+ }
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-plugin-file/blob/05e393dd/doc/pl/index.md
----------------------------------------------------------------------
diff --git a/doc/pl/index.md b/doc/pl/index.md
new file mode 100644
index 0000000..fec09ae
--- /dev/null
+++ b/doc/pl/index.md
@@ -0,0 +1,201 @@
+<!---
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+
+# org.apache.cordova.file
+
+Plugin daje [HTML5 API systemu plików][1]. Za zwyczaj odnoszą się do skały HTML5 [plików artykuł][2] na ten temat. Omówienie innych opcji przechowywania odnoszą się do Cordova z [magazynu przewodnik][3].
+
+ [1]: http://dev.w3.org/2009/dap/file-system/pub/FileSystem/
+ [2]: http://www.html5rocks.com/en/tutorials/file/filesystem/
+ [3]: http://cordova.apache.org/docs/en/edge/cordova_storage_storage.md.html
+
+## Instalacji
+
+ cordova plugin add org.apache.cordova.file
+
+
+## Obsługiwane platformy
+
+* Amazon ogień OS
+* Android
+* Jeżyna 10
+* iOS
+* Windows Phone 7 i 8 *
+* Windows 8 *
+* Firefox OS
+
+* *Nie obsługują te platformy `FileReader.readAsArrayBuffer` , ani `FileWriter.write(blob)` .*
+
+## Gdzie przechowywać pliki
+
+Od v1.2.0 znajdują się adresy URL do katalogów ważne systemu plików. Każdy adres URL jest w formie *file:///path/to/spot/*i mogą być konwertowane na `DirectoryEntry` za pomocą`window.resolveLocalFileSystemURL()`.
+
+`cordova.file.applicationDirectory`-Tylko do odczytu katalogu gdzie jest zainstalowana aplikacja. (*iOS*, *Android*)
+
+`cordova.file.applicationStorageDirectory`-Pierwiastek z prywatnego składowania zapisu aplikacji. (*iOS*, *Android*)
+
+`cordova.file.dataDirectory`-Gdzie umieścić pliki dane specyficzne dla aplikacji. (*iOS*, *Android*)
+
+`cordova.file.cacheDirectory`-W pamięci podręcznej plików, które powinny przetrwać aplikacja zostanie ponownie uruchomiony. Aplikacje nie powinny polegać na OS, aby usunąć pliki tutaj. (*iOS*, *Android*)
+
+`cordova.file.externalApplicationStorageDirectory`-Stosowania przestrzeni na zewnętrznej pamięci masowej. (*iOS*, *Android*)
+
+`cordova.file.externalDataDirectory`-Gdzie umieścić pliki danych specyficznych dla aplikacji na zewnętrznej pamięci masowej. (*Android*)
+
+`cordova.file.externalCacheDirectory`-Pamięci podręcznej aplikacji na zewnętrznej pamięci masowej. (*Android*)
+
+`cordova.file.externalRootDirectory`-Korzeń zewnętrznej pamięci masowej (karty SD). (*Android*)
+
+`cordova.file.tempDirectory`-Temp katalogu systemu operacyjnego można wyczyścić w będzie. (*iOS*)
+
+`cordova.file.syncedDataDirectory`-Posiada pliki specyficzne dla aplikacji, które powinny być zsynchronizowane (np. do iCloud). (*iOS*)
+
+`cordova.file.documentsDirectory`-Pliki prywatne do aplikacji, ale że są znaczące dla innych applciations (np. plików pakietu Office). (*iOS*)
+
+## Android dziwactwa
+
+### Lokalizacja przechowywania trwałych Android
+
+Istnieje wiele prawidłowe lokalizacje do przechowywania trwałych plików na telefonie z systemem Android. Zobacz [tę stronę][4] do szerokiej dyskusji o różnych możliwościach.
+
+ [4]: http://developer.android.com/guide/topics/data/data-storage.html
+
+Poprzednie wersje pluginu wybrać lokalizację plików tymczasowych i trwałe podczas uruchamiania, czy urządzenie twierdził, że karta SD (lub równoważne magazynowanie podzia³) był montowany w oparciu. Czy karta SD została zamontowana, czy duży wewnętrzny magazynowanie podzia³ był dostępny (takie jak na Nexus urządzenia,) a następnie trwałe pliki będą przechowywane w katalogu głównego tego miejsca. Oznaczało to, że wszystkie aplikacje Cordova może Zobacz wszystkie pliki dostępne na karcie.
+
+Jeśli karta SD nie był dostępny, poprzednie wersje będzie przechowywać dane w /data/danych /<packageid>, która izoluje aplikacje od siebie, ale nadal może spowodować danych, które mają być współużytkowane przez użytkowników.
+
+Teraz jest możliwe, aby zdecydować, czy do przechowywania plików w lokalizacji magazynu plików, lub przy użyciu poprzednich logiki, z preferencją w aplikacji w pliku config.xml. Aby to zrobić, Dodaj jedną z tych dwóch linii do pliku config.xml:
+
+ <preference name="AndroidPersistentFileLocation" value="Internal" />
+
+ <preference name="AndroidPersistentFileLocation" value="Compatibility" />
+
+
+Bez tej linii wtyczki pliku będzie używać "Zgodność" jako domyślny. Jeśli znacznik preferencji jest obecny i to nie jedną z tych wartości, aplikacja nie zostanie uruchomiona.
+
+Jeśli aplikacja wcześniej zostało wysłane do użytkowników, przy użyciu starszych (pre-1.0) wersję tego pluginu i ma zapisane na dysku pliki w trwałych plików, a następnie należy ustawić preferencje "Zgodności". Przełączania lokalizacji do "Wewnętrznego" oznacza, że istniejących użytkowników, którzy ich aplikacja może być niesłabnący wobec dostęp ich wcześniej zapisane pliki, w zależności od ich urządzenie.
+
+Jeśli aplikacja jest nowy, lub ma nigdy wcześniej przechowywane pliki w systemie plików trwałe, ustawienie "wewnętrznego" Generalnie jest zalecane.
+
+## iOS dziwactwa
+
+* `FileReader.readAsText(blob, encoding)`
+ * `encoding`Parametr nie jest obsługiwana, i kodowanie UTF-8 jest zawsze w efekcie.
+
+### iOS lokalizacja przechowywania trwałych
+
+Istnieją dwa ważne miejsca trwałe pliki na urządzenia iOS: katalogu dokumentów i katalogu biblioteki. Poprzednie wersje pluginu tylko kiedykolwiek przechowywane trwałe pliki w katalogu dokumentów. To miał ten efekt uboczny od rozpoznawalności wszystkie pliki aplikacji w iTunes, który był często niezamierzone, zwłaszcza dla aplikacji, które obsługują wiele małych plików, zamiast produkuje kompletne dokumenty do wywozu, który jest przeznaczenie katalogu.
+
+Teraz jest możliwe, aby zdecydować, czy do przechowywania plików w dokumentach lub katalogu biblioteki, z preferencją w pliku config.xml aplikacji. Aby to zrobić, Dodaj jedną z tych dwóch linii do pliku config.xml:
+
+ <preference name="iosPersistentFileLocation" value="Library" />
+
+ <preference name="iosPersistentFileLocation" value="Compatibility" />
+
+
+Bez tej linii wtyczki pliku będzie używać "Zgodność" jako domyślny. Jeśli znacznik preferencji jest obecny i to nie jedną z tych wartości, aplikacja nie zostanie uruchomiona.
+
+Jeśli aplikacja wcześniej zostało wysłane do użytkowników, przy użyciu starszych (pre-1.0) wersję tego pluginu i ma zapisane na dysku pliki w trwałych plików, a następnie należy ustawić preferencje "Zgodności". Przełączania lokalizacji "Biblioteki" oznacza, że istniejących użytkowników, którzy ich aplikacja będzie niesłabnący wobec dostęp ich wcześniej zapisane pliki.
+
+Jeśli aplikacja jest nowy, lub ma nigdy wcześniej przechowywane pliki w systemie plików trwałe, ustawienie "Biblioteki" Generalnie jest zalecane.
+
+### Firefox OS dziwactwa
+
+API systemu plików nie jest obsługiwany macierzyście przez Firefox OS i jest zaimplementowany jako podkładki na indexedDB.
+
+* Nie usuwając niepuste katalogi
+* Nie obsługuje metadane dla katalogów
+* Nie obsługuje `requestAllFileSystems` i `resolveLocalFileSystemURI` metody
+* Metody `copyTo` i `moveTo` nie obsługuje katalogi
+
+## Uaktualniania notatek
+
+W v1.0.0 ten plugin `FileEntry` i `DirectoryEntry` struktur zmieniły się, aby być bardziej zgodnie z opublikowaną specyfikacją.
+
+Poprzednie wersje (pre-1.0.0) plugin przechowywane urządzenia bezwzględna plik lokalizacja w `fullPath` Właściwość `Entry` obiektów. Te ścieżki zazwyczaj będzie wyglądać
+
+ /var/mobile/Applications/<application UUID>/Documents/path/to/file (iOS)
+ /storage/emulated/0/path/to/file (Android)
+
+
+Te ścieżki również zostały zwrócone przez `toURL()` Metoda `Entry` obiektów.
+
+Z v1.0.0 `fullPath` atrybut jest ścieżką do pliku, *względem katalogu głównego systemu plików HTML*. Tak, powyżej ścieżki będzie teraz zarówno reprezentowana przez `FileEntry` obiekt z `fullPath` z
+
+ /path/to/file
+
+
+Jeśli aplikacja działa z ścieżki bezwzględnej urządzeń, i możesz wcześniej źródło tych ścieżek za pomocą `fullPath` Właściwość `Entry` obiektów, a następnie należy zaktualizować kod, aby użyć `entry.toURL()` zamiast.
+
+Do tyłu zgodności, `resolveLocalFileSystemURL()` Metoda akceptuje pomysł ścieżka bezwzględna i zwróci `Entry` obiektu odpowiadającego mu, tak długo, jak ten plik istnieje w tymczasowe lub trwałe systemy plików.
+
+To szczególnie został problem z pluginem transferu plików, które poprzednio używane ścieżki bezwzględnej urządzeń (i wciąż można je przyjąć). To został zaktualizowany, aby działać poprawnie z adresów URL plików, więc wymiana `entry.fullPath` z `entry.toURL()` powinno rozwiązać wszelkie problemy dostawanie ten plugin do pracy z plików w pamięci urządzenia.
+
+W v1.1.0 wartość zwracana z `toURL()` został zmieniony (patrz \[CB-6394\] (https://issues.apache.org/jira/browse/CB-6394)) zwraca adres URL absolutnej "file://". wszędzie tam, gdzie jest to możliwe. Aby zapewnić ' cdvfile:'-URL można użyć `toInternalURL()` teraz. Ta metoda zwróci teraz adresy URL plików formularza
+
+ cdvfile://localhost/persistent/path/to/file
+
+
+który służy do jednoznacznej identyfikacji pliku.
+
+## Wykaz kodów błędów i ich znaczenie
+
+Gdy błąd jest generowany, jeden z następujących kodów będzie służyć.
+
+* 1 = NOT\_FOUND\_ERR
+* 2 = SECURITY_ERR
+* 3 = ABORT_ERR
+* 4 = NOT\_READABLE\_ERR
+* 5 = ENCODING_ERR
+* 6 = NO\_MODIFICATION\_ALLOWED_ERR
+* 7 = INVALID\_STATE\_ERR
+* 8 = SYNTAX_ERR
+* 9 = INVALID\_MODIFICATION\_ERR
+* 10 = QUOTA\_EXCEEDED\_ERR
+* 11 = TYPE\_MISMATCH\_ERR
+* 12 = PATH\_EXISTS\_ERR
+
+## Konfigurowanie wtyczka (opcjonalny)
+
+Zestaw dostępnych plików może być skonfigurowany na platformie. Zarówno iOS i Android <preference> uchwyt w `config.xml` które nazwy plików do instalacji. Domyślnie włączone są wszystkie korzenie systemu plików.
+
+ <preference name="iosExtraFilesystems" value="library,library-nosync,documents,documents-nosync,cache,bundle,root" />
+ <preference name="AndroidExtraFilesystems" value="files,files-external,documents,sdcard,cache,cache-external,root" />
+
+
+### Android
+
+* pliki: katalogu przechowywania plików aplikacji
+* zewnętrzne pliki: katalog aplikacji zewnętrznych plików
+* sdcard: katalog globalny plik zewnętrzny (to jest głównym karty SD, jeśli jedna jest zainstalowana). Musisz mieć `android.permission.WRITE_EXTERNAL_STORAGE` uprawnienie do korzystania z tego.
+* pamięć podręczna: katalogu wewnętrznej pamięci podręcznej aplikacji
+* pamięci podręcznej zewnętrzne: katalogu aplikacji zewnętrznych pamięci podręcznej
+* korzeń: całe urządzenie systemu plików
+
+Android obsługuje również specjalnych plików o nazwie "dokumenty", który reprezentuje podkatalog "/ dokumenty /" w ramach systemu plików "pliki".
+
+### iOS
+
+* Biblioteka: katalog biblioteki aplikacji
+* dokumenty: dokumenty katalogu aplikacji
+* pamięć podręczna: katalogu pamięci podręcznej aplikacji
+* pakiet: pakiet aplikacji; Lokalizacja aplikacji na dysku (tylko do odczytu)
+* korzeń: całe urządzenie systemu plików
+
+Domyślnie katalogi biblioteki i dokumenty mogą być synchronizowane iCloud. Można również zażądać dwóch dodatkowych plików, "biblioteka nosync" i "dokumenty nosync", które stanowią specjalny katalog nie zsynchronizowane w bibliotece lub dokumentów systemu plików.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-plugin-file/blob/05e393dd/doc/pl/plugins.md
----------------------------------------------------------------------
diff --git a/doc/pl/plugins.md b/doc/pl/plugins.md
new file mode 100644
index 0000000..a1f9169
--- /dev/null
+++ b/doc/pl/plugins.md
@@ -0,0 +1,124 @@
+<!---
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+
+# Uwagi dla programistów wtyczki
+
+Te notatki są przeznaczone przede wszystkim dla Androida i iOS programistów, którzy chcieli pisac pluginy które interfejs z systemu plików za pomocą wtyczki pliku.
+
+## Praca z Cordova pliku system adresów URL
+
+Od wersji 1.0.0, ten plugin jest używane adresy URL z `cdvfile` system do komunikacji przez most, a nie narażać urządzenia raw ścieżki systemu plików JavaScript.
+
+Na stronie JavaScript oznacza to, że FileEntry i DirectoryEntry obiekty mają fullPath atrybut, który jest głównym systemie plików HTML. Jeśli twój plugin JavaScript API akceptuje obiektu DirectoryEntry lub FileEntry, należy zadzwonić `.toURL()` na obiekt przed przekazaniem przez most do kodu macierzystego.
+
+### Konwersja cdvfile: / / URL do ścieżki fileystem
+
+Wtyczek, które trzeba pisać do systemu plików może chcesz przekonwertować odebranych plików systemu adres URL lokalizacji rzeczywistych plików. Istnieje wiele sposobów działania, od macierzystego platformy.
+
+Ważne jest, aby pamiętać, że nie wszystkie `cdvfile://` adresy URL są można zmapować na prawdziwe akta urządzeniu. Niektóre adresy URL może odnosić się do aktywów na urządzeniu, które nie są reprezentowane przez pliki, lub nawet może odnosić się do zasobów zdalnych. Z powodu tych możliwości wtyczki należy zawsze sprawdzić, czy się znaczących wyników wstecz, podczas próby konwersji adresów URL do ścieżki.
+
+#### Android
+
+Na Android, najprostsza metoda konwersji `cdvfile://` URL do ścieżki systemu plików jest użycie `org.apache.cordova.CordovaResourceApi` . `CordovaResourceApi`jest kilka metod, które mogą obsługiwać `cdvfile://` adresów URL:
+
+ // webView is a member of the Plugin class
+ CordovaResourceApi resourceApi = webView.getResourceApi();
+
+ // Obtain a file:/// URL representing this file on the device,
+ // or the same URL unchanged if it cannot be mapped to a file
+ Uri fileURL = resourceApi.remapUri(Uri.parse(cdvfileURL));
+
+
+Jest również możliwe, aby korzystać z wtyczki pliku bezpośrednio:
+
+ import org.apache.cordova.file.FileUtils;
+ import org.apache.cordova.file.FileSystem;
+ import java.net.MalformedURLException;
+
+ // Get the File plugin from the plugin manager
+ FileUtils filePlugin = (FileUtils)webView.pluginManager.getPlugin("File");
+
+ // Given a URL, get a path for it
+ try {
+ String path = filePlugin.filesystemPathForURL(cdvfileURL);
+ } catch (MalformedURLException e) {
+ // The filesystem url wasn't recognized
+ }
+
+
+Do przeliczenia ścieżki do `cdvfile://` adres URL:
+
+ import org.apache.cordova.file.LocalFilesystemURL;
+
+ // Get a LocalFilesystemURL object for a device path,
+ // or null if it cannot be represented as a cdvfile URL.
+ LocalFilesystemURL url = filePlugin.filesystemURLforLocalPath(path);
+ // Get the string representation of the URL object
+ String cdvfileURL = url.toString();
+
+
+Jeśli twój plugin tworzy plik, i chcesz zwraca obiekt FileEntry dla niego, użyj pliku plugin:
+
+ // Return a JSON structure suitable for returning to JavaScript,
+ // or null if this file is not representable as a cdvfile URL.
+ JSONObject entry = filePlugin.getEntryForFile(file);
+
+
+#### iOS
+
+Cordova na iOS nie korzystać z tego samego `CordovaResourceApi` koncepcji jak Android. Na iOS należy użyć pliku plugin do konwersji między adresach URL i ścieżkach plików.
+
+ // Get a CDVFilesystem URL object from a URL string
+ CDVFilesystemURL* url = [CDVFilesystemURL fileSystemURLWithString:cdvfileURL];
+ // Get a path for the URL object, or nil if it cannot be mapped to a file
+ NSString* path = [filePlugin filesystemPathForURL:url];
+
+
+ // Get a CDVFilesystem URL object for a device path, or
+ // nil if it cannot be represented as a cdvfile URL.
+ CDVFilesystemURL* url = [filePlugin fileSystemURLforLocalPath:path];
+ // Get the string representation of the URL object
+ NSString* cdvfileURL = [url absoluteString];
+
+
+Jeśli twój plugin tworzy plik, i chcesz zwraca obiekt FileEntry dla niego, użyj pliku plugin:
+
+ // Get a CDVFilesystem URL object for a device path, or
+ // nil if it cannot be represented as a cdvfile URL.
+ CDVFilesystemURL* url = [filePlugin fileSystemURLforLocalPath:path];
+ // Get a structure to return to JavaScript
+ NSDictionary* entry = [filePlugin makeEntryForLocalURL:url]
+
+
+#### JavaScript
+
+W JavaScript, aby uzyskać `cdvfile://` adres URL z obiektu FileEntry lub DirectoryEntry, wystarczy zadzwonić `.toURL()` na to:
+
+ var cdvfileURL = entry.toURL();
+
+
+W plugin obsługi odpowiedzi do przeliczenia strukturę FileEntry wrócił do rzeczywistego obiektu wejścia, kod obsługi należy importować pliku plugin i utworzyć nowy obiekt:
+
+ // create appropriate Entry object
+ var entry;
+ if (entryStruct.isDirectory) {
+ entry = new DirectoryEntry(entryStruct.name, entryStruct.fullPath, new FileSystem(entryStruct.filesystemName));
+ } else {
+ entry = new FileEntry(entryStruct.name, entryStruct.fullPath, new FileSystem(entryStruct.filesystemName));
+ }
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-plugin-file/blob/05e393dd/doc/zh/index.md
----------------------------------------------------------------------
diff --git a/doc/zh/index.md b/doc/zh/index.md
new file mode 100644
index 0000000..aa910fa
--- /dev/null
+++ b/doc/zh/index.md
@@ -0,0 +1,201 @@
+<!---
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+
+# org.apache.cordova.file
+
+這個外掛程式提供了[HTML5 檔案系統 API][1]。 用法,請參閱 HTML5 岩石[檔案系統條][2]關於這個問題。 其他存儲選項的概述,請參閱科爾多瓦的[存儲指南][3].
+
+ [1]: http://dev.w3.org/2009/dap/file-system/pub/FileSystem/
+ [2]: http://www.html5rocks.com/en/tutorials/file/filesystem/
+ [3]: http://cordova.apache.org/docs/en/edge/cordova_storage_storage.md.html
+
+## 安裝
+
+ cordova plugin add org.apache.cordova.file
+
+
+## 支援的平臺
+
+* 亞馬遜火 OS
+* Android 系統
+* 黑莓 10
+* iOS
+* Windows Phone 7 和 8 *
+* Windows 8 *
+* 火狐瀏覽器作業系統
+
+**這些平臺不支援 `FileReader.readAsArrayBuffer` ,也不 `FileWriter.write(blob)` .*
+
+## 存儲檔的位置
+
+自 v1.2.0,提供重要的檔案系統目錄的 Url。 每個 URL 是在表單*file:///path/to/spot/*,和可以轉換為 `DirectoryEntry` 使用`window.resolveLocalFileSystemURL()`.
+
+`cordova.file.applicationDirectory`-唯讀目錄應用程式的安裝位置。(*iOS* *Android*)
+
+`cordova.file.applicationStorageDirectory`-應用程式的私有可寫存儲的根。(*iOS* *Android*)
+
+`cordova.file.dataDirectory`-在何處放置應用程式特定的資料檔案。(*iOS* *Android*)
+
+`cordova.file.cacheDirectory`-緩存應該生存重新開機應用程式的檔。應用程式不應依賴 OS,以刪除檔在這裡。(*iOS* *Android*)
+
+`cordova.file.externalApplicationStorageDirectory`-應用程式外部存儲上的空間。(*iOS* *Android*)
+
+`cordova.file.externalDataDirectory`-要把外部存儲的特定于應用程式資料檔案的位置。(*Android*)
+
+`cordova.file.externalCacheDirectory`外部存儲的應用程式緩存。(*Android*)
+
+`cordova.file.externalRootDirectory`-外部存儲 (SD 卡) 根。(*Android*)
+
+`cordova.file.tempDirectory`-將 OS 可以清除時的 temp 目錄。(*iOS*)
+
+`cordova.file.syncedDataDirectory`-持有應同步 (例如到 iCloud) 的應用程式特定的檔。(*iOS*)
+
+`cordova.file.documentsDirectory`-檔專用的應用程式,但這是對其他 applciations (例如 Office 檔) 有意義。(*iOS*)
+
+## Android 的怪癖
+
+### Android 的永久存儲位置
+
+有多個存儲持久性 Android 設備上的檔的有效位置。 請參閱[此頁][4]為廣泛地討論的各種可能性。
+
+ [4]: http://developer.android.com/guide/topics/data/data-storage.html
+
+以前版本的外掛程式會選擇在啟動時,基於是否該設備聲稱 SD 卡 (或等效存儲分區) 安裝臨時和永久檔的位置。 如果被掛載 SD 卡,或者如果一個大的內部存儲分區是可用 (如 Nexus 的設備上,) 然後持久性檔將存儲在該空間的根。 這就意味著所有的科爾多瓦應用可以看到所有可用的檔在卡上。
+
+如果 SD 卡不是可用的然後以前的版本會將資料存儲在下/資料/資料 /<packageid>其中隔離應用程式從彼此,但仍然可能會導致使用者之間共用資料。
+
+現在可以選擇是否要將檔存儲在內部檔存儲位置,或使用以前的邏輯,在您的應用程式的 config.xml 檔首選項。 若要執行此操作,請將這兩行之一添加到 config.xml:
+
+ <preference name="AndroidPersistentFileLocation" value="Internal" />
+
+ <preference name="AndroidPersistentFileLocation" value="Compatibility" />
+
+
+如果這條線,沒有檔外掛程式將作為預設值使用"相容性"。如果首選項標記是存在,並不是這些值之一,應用程式將無法啟動。
+
+如果您的應用程式先前已經運送到使用者,使用較舊的 (預 1.0) 的這個外掛程式版本和已存儲的檔中的持久性的檔案系統,然後您應該設置的首選項的"相容性"。 切換到"內部"的位置就意味著現有使用者升級他們的應用程式可能無法訪問他們以前存儲的檔,他們的設備。
+
+如果您的應用程式是新的或以前從未有持久性檔案系統中存儲的檔,然後通常會建議的"內部"的設置。
+
+## iOS 的怪癖
+
+* `FileReader.readAsText(blob, encoding)`
+ * `encoding`參數不受支援,和 utf-8 編碼總是有效。
+
+### iOS 的持久性存儲位置
+
+有兩個有效位置來存儲持久性的 iOS 設備上的檔: 檔目錄和庫目錄。 以前版本的外掛程式只過持久性檔存儲在檔目錄中。 這有副作用 — — 使所有的應用程式的檔可見在 iTunes 中,往往是意料之外的特別是為處理大量小檔的應用程式,而不是生產用於出口,是預期的目的的目錄的完整的檔。
+
+現在可以選擇是否要將檔存儲在檔或庫目錄,與您的應用程式的 config.xml 檔中的偏好。 若要執行此操作,請將這兩行之一添加到 config.xml:
+
+ <preference name="iosPersistentFileLocation" value="Library" />
+
+ <preference name="iosPersistentFileLocation" value="Compatibility" />
+
+
+如果這條線,沒有檔外掛程式將作為預設值使用"相容性"。如果首選項標記是存在,並不是這些值之一,應用程式將無法啟動。
+
+如果您的應用程式先前已經運送到使用者,使用較舊的 (預 1.0) 的這個外掛程式版本和已存儲的檔中的持久性的檔案系統,然後您應該設置的首選項的"相容性"。 切換到"庫"的位置意味著升級他們的應用程式的現有使用者將無法訪問他們以前存儲的檔。
+
+如果您的應用程式是新的或以前從未有持久性檔案系統中存儲的檔,然後通常會建議"的庫"設置。
+
+### 火狐瀏覽器作業系統的怪癖
+
+檔案系統 API 本機作業系統不支援火狐瀏覽器,在 indexedDB shim 作為實現的。
+
+* 不會失敗時刪除非空的目錄
+* 不支援用中繼資料的目錄
+* 不支援 `requestAllFileSystems` 和 `resolveLocalFileSystemURI` 的方法
+* 方法 `copyTo` 和 `moveTo` 不支援目錄
+
+## 升級說明
+
+在此外掛程式 v1.0.0 `FileEntry` 和 `DirectoryEntry` 結構已經更改,以更符合已發佈的規範。
+
+以前 (pre-1.0.0) 版本的外掛程式存儲的設備-絕對-檔-位置在 `fullPath` 屬性的 `Entry` 物件。這些路徑通常看起來就像
+
+ /var/mobile/Applications/<application UUID>/Documents/path/to/file (iOS)
+ /storage/emulated/0/path/to/file (Android)
+
+
+這些路徑還返回的 `toURL()` 方法的 `Entry` 物件。
+
+與 v1.0.0, `fullPath` 屬性是對該檔*的 HTML 檔案系統根目錄的相對*路徑。 因此,上述路徑會現在兩者都由表示 `FileEntry` 物件與 `fullPath` 的
+
+ /path/to/file
+
+
+如果您的應用程式與設備-絕對路徑,和你以前檢索到這些路徑通過 `fullPath` 屬性的 `Entry` 物件,然後你應該更新您的代碼以使用 `entry.toURL()` 相反。
+
+為向後相容性, `resolveLocalFileSystemURL()` 方法將接受絕對設備的路徑,並將返回 `Entry` 對應于它,只要該檔存在的臨時或永久性的檔案系統內的物件。
+
+這特別是一直帶有檔案傳輸外掛程式,以前使用過的設備絕對路徑的問題 (和仍然可以接受他們)。 它已更新為與檔案系統的 Url,所以取代正常工作 `entry.fullPath` 與 `entry.toURL()` 應解決獲取該外掛程式來處理檔的設備上的任何問題。
+
+V1.1.0 的傳回值中的 `toURL()` 已更改 (請參見 \[CB-6394\] (HTTPs://issues.apache.org/jira/browse/CB-6394)) 返回一個絕對 'file:// URL。 在可能的情況。 為確保 ' cdvfile:'-您可以使用的 URL `toInternalURL()` 現在。 現在,此方法將返回該表單的檔案系統 Url
+
+ cdvfile://localhost/persistent/path/to/file
+
+
+它可以用於唯一地標識該檔。
+
+## 錯誤代碼和含義的清單
+
+錯誤引發時,將使用以下代碼之一。
+
+* 1 = NOT\_FOUND\_ERR
+* 2 = SECURITY_ERR
+* 3 = ABORT_ERR
+* 4 = NOT\_READABLE\_ERR
+* 5 = ENCODING_ERR
+* 6 = NO\_MODIFICATION\_ALLOWED_ERR
+* 7 = INVALID\_STATE\_ERR
+* 8 = SYNTAX_ERR
+* 9 = INVALID\_MODIFICATION\_ERR
+* 10 = QUOTA\_EXCEEDED\_ERR
+* 11 = TYPE\_MISMATCH\_ERR
+* 12 = PATH\_EXISTS\_ERR
+
+## 配置的外掛程式 (可選)
+
+可用的檔案系統的一組可配置的每個平臺。IOS 和 android 系統識別 <preference> 在中添加標籤 `config.xml` 的名字要安裝的檔案系統。預設情況下,啟用所有檔案系統根。
+
+ <preference name="iosExtraFilesystems" value="library,library-nosync,documents,documents-nosync,cache,bundle,root" />
+ <preference name="AndroidExtraFilesystems" value="files,files-external,documents,sdcard,cache,cache-external,root" />
+
+
+### Android 系統
+
+* 檔: 應用程式的內部檔存儲目錄
+* 檔外部: 應用程式的外部檔存儲目錄
+* sdcard: 全球外部檔存儲目錄 (如果安裝了一個,這是 SD 卡的根目錄)。 您必須具有 `android.permission.WRITE_EXTERNAL_STORAGE` 使用此許可權。
+* 快取記憶體: 應用程式的內部緩存目錄
+* 外部快取記憶體: 應用程式的外部快取記憶體目錄
+* 根: 整個設備的檔案系統
+
+Android 還支援名為"檔",它表示"檔的"檔案系統中的子目錄"/ 檔 /"特別的檔案系統。
+
+### iOS
+
+* 圖書館: 應用程式的庫目錄
+* 文檔: 應用程式的檔目錄
+* 快取記憶體: 應用程式的緩存目錄
+* 束: 束應用程式的 ;應用程式本身 (唯讀) 的磁片上的位置
+* 根: 整個設備的檔案系統
+
+預設情況下,圖書館和檔目錄可以同步到 iCloud。 你也可以要求兩個附加檔案系統、"圖書館-非同步"和"文檔-nosync",代表特別的非同步的目錄內的庫或檔的檔案系統。
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-plugin-file/blob/05e393dd/doc/zh/plugins.md
----------------------------------------------------------------------
diff --git a/doc/zh/plugins.md b/doc/zh/plugins.md
new file mode 100644
index 0000000..462fb06
--- /dev/null
+++ b/doc/zh/plugins.md
@@ -0,0 +1,124 @@
+<!---
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+
+# 外掛程式開發人員須知
+
+這些筆記主要針對 Android 和 iOS 開發者想要使用的檔案系統使用的檔外掛程式編寫外掛程式哪個介面。
+
+## 工作與科爾多瓦檔案系統 Url
+
+1.0.0 版以來,這個外掛程式用了 Url 與 `cdvfile` 在橋樑,為所有的通信計畫,而不是暴露 JavaScript 原始設備的檔案系統路徑。
+
+在 JavaScript 方面,這意味著 FileEntry 和 DirectoryEntry 的物件具有一個完整路徑屬性是相對於 HTML 檔案系統的根目錄。 如果你的外掛程式的 JavaScript API 接受 FileEntry 或 DirectoryEntry 的物件,則應調用 `.toURL()` 對該物件之前將它在橋上傳遞給本機代碼。
+
+### 轉換 cdvfile: / / fileystem 的路徑的 Url
+
+需要寫入到檔案系統的外掛程式可能會想要將收到的檔案系統的 URL 轉換為實際的檔案系統位置。有多種方法做這個,根據本機平臺。
+
+它是重要的是要記住,不是所有 `cdvfile://` 的 Url 均可映射到設備上的實際檔。 某些 Url 可以引用在設備上不是由檔,或甚至可以引用遠端資源的資產。 由於這些可能性,外掛程式應始終測試是否回試圖將 Url 轉換成路徑時,他們得到有意義的結果。
+
+#### Android 系統
+
+在 android 系統,最簡單的方法來轉換 `cdvfile://` 檔案系統路徑的 URL 是使用 `org.apache.cordova.CordovaResourceApi` 。 `CordovaResourceApi`有幾種方法,可處理 `cdvfile://` 的 Url:
+
+ // webView is a member of the Plugin class
+ CordovaResourceApi resourceApi = webView.getResourceApi();
+
+ // Obtain a file:/// URL representing this file on the device,
+ // or the same URL unchanged if it cannot be mapped to a file
+ Uri fileURL = resourceApi.remapUri(Uri.parse(cdvfileURL));
+
+
+它也是可以直接使用檔外掛程式:
+
+ import org.apache.cordova.file.FileUtils;
+ import org.apache.cordova.file.FileSystem;
+ import java.net.MalformedURLException;
+
+ // Get the File plugin from the plugin manager
+ FileUtils filePlugin = (FileUtils)webView.pluginManager.getPlugin("File");
+
+ // Given a URL, get a path for it
+ try {
+ String path = filePlugin.filesystemPathForURL(cdvfileURL);
+ } catch (MalformedURLException e) {
+ // The filesystem url wasn't recognized
+ }
+
+
+要轉換的路徑從 `cdvfile://` 的 URL:
+
+ import org.apache.cordova.file.LocalFilesystemURL;
+
+ // Get a LocalFilesystemURL object for a device path,
+ // or null if it cannot be represented as a cdvfile URL.
+ LocalFilesystemURL url = filePlugin.filesystemURLforLocalPath(path);
+ // Get the string representation of the URL object
+ String cdvfileURL = url.toString();
+
+
+如果你的外掛程式創建一個檔,並且您想要為它返回一個 FileEntry 物件,使用該檔外掛程式:
+
+ // Return a JSON structure suitable for returning to JavaScript,
+ // or null if this file is not representable as a cdvfile URL.
+ JSONObject entry = filePlugin.getEntryForFile(file);
+
+
+#### iOS
+
+科爾多瓦在 iOS 上的不使用相同 `CordovaResourceApi` 作為 android 系統的概念。在 iOS,應使用檔外掛程式的 Url 和檔案系統路徑之間進行轉換。
+
+ // Get a CDVFilesystem URL object from a URL string
+ CDVFilesystemURL* url = [CDVFilesystemURL fileSystemURLWithString:cdvfileURL];
+ // Get a path for the URL object, or nil if it cannot be mapped to a file
+ NSString* path = [filePlugin filesystemPathForURL:url];
+
+
+ // Get a CDVFilesystem URL object for a device path, or
+ // nil if it cannot be represented as a cdvfile URL.
+ CDVFilesystemURL* url = [filePlugin fileSystemURLforLocalPath:path];
+ // Get the string representation of the URL object
+ NSString* cdvfileURL = [url absoluteString];
+
+
+如果你的外掛程式創建一個檔,並且您想要為它返回一個 FileEntry 物件,使用該檔外掛程式:
+
+ // Get a CDVFilesystem URL object for a device path, or
+ // nil if it cannot be represented as a cdvfile URL.
+ CDVFilesystemURL* url = [filePlugin fileSystemURLforLocalPath:path];
+ // Get a structure to return to JavaScript
+ NSDictionary* entry = [filePlugin makeEntryForLocalURL:url]
+
+
+#### JavaScript
+
+在 JavaScript 中,得到 `cdvfile://` URL 從 FileEntry 或 DirectoryEntry 的物件,只需調用 `.toURL()` 對它:
+
+ var cdvfileURL = entry.toURL();
+
+
+在外掛程式回應處理常式,將從返回的 FileEntry 結構轉換為實際的輸入物件,您的處理常式代碼應該導入的檔外掛程式並創建一個新的物件:
+
+ // create appropriate Entry object
+ var entry;
+ if (entryStruct.isDirectory) {
+ entry = new DirectoryEntry(entryStruct.name, entryStruct.fullPath, new FileSystem(entryStruct.filesystemName));
+ } else {
+ entry = new FileEntry(entryStruct.name, entryStruct.fullPath, new FileSystem(entryStruct.filesystemName));
+ }
\ No newline at end of file
[2/2] git commit: CB-6127 Spanish and French Translations added.
Github close #31
Posted by st...@apache.org.
CB-6127 Spanish and French Translations added. Github close #31
Project: http://git-wip-us.apache.org/repos/asf/cordova-plugin-file/repo
Commit: http://git-wip-us.apache.org/repos/asf/cordova-plugin-file/commit/05e393dd
Tree: http://git-wip-us.apache.org/repos/asf/cordova-plugin-file/tree/05e393dd
Diff: http://git-wip-us.apache.org/repos/asf/cordova-plugin-file/diff/05e393dd
Branch: refs/heads/master
Commit: 05e393ddb30b3182d67920ba5e3bea7fbfb512db
Parents: 12cb045
Author: ldeluca <ld...@us.ibm.com>
Authored: Wed Feb 26 09:35:59 2014 -0500
Committer: Steven Gill <st...@gmail.com>
Committed: Wed Jun 4 16:26:06 2014 -0700
----------------------------------------------------------------------
doc/de/index.md | 201 +++++++++++++++++++++++++++++++++++++++++++++++++
doc/de/plugins.md | 124 ++++++++++++++++++++++++++++++
doc/es/index.md | 201 +++++++++++++++++++++++++++++++++++++++++++++++++
doc/es/plugins.md | 124 ++++++++++++++++++++++++++++++
doc/fr/index.md | 201 +++++++++++++++++++++++++++++++++++++++++++++++++
doc/fr/plugins.md | 124 ++++++++++++++++++++++++++++++
doc/it/index.md | 201 +++++++++++++++++++++++++++++++++++++++++++++++++
doc/it/plugins.md | 124 ++++++++++++++++++++++++++++++
doc/ja/index.md | 201 +++++++++++++++++++++++++++++++++++++++++++++++++
doc/ja/plugins.md | 124 ++++++++++++++++++++++++++++++
doc/ko/index.md | 201 +++++++++++++++++++++++++++++++++++++++++++++++++
doc/ko/plugins.md | 124 ++++++++++++++++++++++++++++++
doc/pl/index.md | 201 +++++++++++++++++++++++++++++++++++++++++++++++++
doc/pl/plugins.md | 124 ++++++++++++++++++++++++++++++
doc/zh/index.md | 201 +++++++++++++++++++++++++++++++++++++++++++++++++
doc/zh/plugins.md | 124 ++++++++++++++++++++++++++++++
16 files changed, 2600 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/cordova-plugin-file/blob/05e393dd/doc/de/index.md
----------------------------------------------------------------------
diff --git a/doc/de/index.md b/doc/de/index.md
new file mode 100644
index 0000000..75b1cc5
--- /dev/null
+++ b/doc/de/index.md
@@ -0,0 +1,201 @@
+<!---
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+
+# org.apache.cordova.file
+
+Dieses Plugin bietet die [HTML5-Dateisystem-API][1]. Verwendung finden Sie unter HTML5 Rocks [FileSystem-Artikel][2] zu diesem Thema. Finden Sie einen Überblick über andere Speicheroptionen Cordovas [Speicher-Führer][3].
+
+ [1]: http://dev.w3.org/2009/dap/file-system/pub/FileSystem/
+ [2]: http://www.html5rocks.com/en/tutorials/file/filesystem/
+ [3]: http://cordova.apache.org/docs/en/edge/cordova_storage_storage.md.html
+
+## Installation
+
+ cordova plugin add org.apache.cordova.file
+
+
+## Unterstützte Plattformen
+
+* Amazon Fire OS
+* Android
+* BlackBerry 10
+* iOS
+* Windows Phone 7 und 8 *
+* Windows 8 *
+* Firefox OS
+
+* *Diese Plattformen unterstützen nicht `FileReader.readAsArrayBuffer` noch `FileWriter.write(blob)` .*
+
+## Wo Dateien gespeichert
+
+Stand: V1 werden URLs auf wichtige Datei-System-Verzeichnisse zur Verfügung gestellt. Jede URL in der Form *file:///path/to/spot/*ist, und konvertiert werden können eine `DirectoryEntry` mit`window.resolveLocalFileSystemURL()`.
+
+`cordova.file.applicationDirectory`-Die schreibgeschützten Verzeichnis, in dem die Anwendung installiert ist. (*iOS*, *Android*)
+
+`cordova.file.applicationStorageDirectory`-Stamm der app's private beschreibbaren Speicher. (*iOS*, *Android*)
+
+`cordova.file.dataDirectory`-Wo app-spezifische Datendateien zu setzen. (*iOS*, *Android*)
+
+`cordova.file.cacheDirectory`-Cache-Dateien, die app startet überleben sollte. Apps sollten nicht vom Betriebssystem zum Löschen von Dateien hier verlassen. (*iOS*, *Android*)
+
+`cordova.file.externalApplicationStorageDirectory`-Anwendungsraum auf externen Speicher. (*iOS*, *Android*)
+
+`cordova.file.externalDataDirectory`-Wo, app-spezifische Datendateien auf externen Speicher setzen. (*Android*)
+
+`cordova.file.externalCacheDirectory`-Anwendungscache auf externen Speicher. (*Android*)
+
+`cordova.file.externalRootDirectory`-Externer Speicher (SD-Karte) Stamm. (*Android*)
+
+`cordova.file.tempDirectory`-Temp-Verzeichnis, dem das OS auf deaktivieren können wird. (*iOS*)
+
+`cordova.file.syncedDataDirectory`-Hält app-spezifische Dateien, die (z. B. auf iCloud) synchronisiert werden sollten. (*iOS*)
+
+`cordova.file.documentsDirectory`-Dateien für die app, aber privat sind sinnvoll, andere Anwendungen (z.B. Office-Dateien). (*iOS*)
+
+## Android Macken
+
+### Android permanenten Speicherort
+
+Es gibt mehrere gültige Speicherorte, persistente Dateien auf einem Android-Gerät zu speichern. Finden Sie auf [dieser Seite][4] eine ausführliche Diskussion über die verschiedenen Möglichkeiten.
+
+ [4]: http://developer.android.com/guide/topics/data/data-storage.html
+
+Frühere Versionen des Plugins wählen würde, den Speicherort der temporären und permanenten Dateien beim Start, basierend auf, ob das Gerät behauptete, dass die SD-Karte (oder gleichwertige Speicherpartition) bereitgestellt wurde. Wenn die SD-Karte eingelegt wurde, oder wenn eine große interne Speicherpartition verfügbar war (wie auf Nexus-Geräten) und dann in die Wurzel dieses Raumes, die persistenten Dateien gespeichert werden. Dies bedeutete, dass alle Cordova apps aller verfügbaren Dateien auf der Karte sehen konnte.
+
+Wenn die SD-Karte nicht verfügbar war, würde dann frühere Versionen unter/Data/Data/Datenspeicher<packageid>, die apps von einander isoliert, kann aber noch Daten für Benutzer freigegeben werden.
+
+Es ist jetzt möglich, ob Sie Dateien der internen Datei-Speicherort oder unter Verwendung der bisherigen Logik, mit einer Präferenz in der Anwendung-config.xml-Datei speichern möchten. Hierzu fügen Sie eine dieser zwei Zeilen zu "config.xml":
+
+ <preference name="AndroidPersistentFileLocation" value="Internal" />
+
+ <preference name="AndroidPersistentFileLocation" value="Compatibility" />
+
+
+Ohne diese Zeile wird die Datei-Erweiterung "Kompatibilität" als Standard verwenden. Wenn ein Präferenz-Tag vorhanden ist, und nicht einen der folgenden Werte, wird die Anwendung nicht gestartet.
+
+Wenn Ihre Anwendung für Benutzer zuvor versandt wird, mithilfe eines älteren (Pre-1.0) Version dieses Plugins und gespeicherte Dateien im permanenten Dateisystem hat, dann setzen Sie die Einstellung auf "Kompatibilität". Wechseln die Location auf "Internal" würde bedeuten, dass Benutzer, die aktualisieren Sie ihre Anwendung, möglicherweise nicht auf ihre zuvor gespeicherte Dateien, abhängig von ihrem Gerät zugreifen.
+
+Wenn Ihre Anwendung neu ist, oder nie zuvor Dateien im Dateisystem persistent gespeichert hat, wird die "interne" Einstellung im Allgemeinen empfohlen.
+
+## iOS Macken
+
+* `FileReader.readAsText(blob, encoding)`
+ * Die `encoding` Parameter wird nicht unterstützt und UTF-8-Kodierung ist immer wirksam.
+
+### iOS permanenten Speicherort
+
+Es gibt zwei gültige Speicherorte persistente Dateien auf ein iOS-Gerät speichern: das Dokumenten-Verzeichnis und das Verzeichnis Library. Frühere Versionen des Plugins gespeichert immer nur persistente Dateien im Verzeichnis Dokumente. Dies hatte den Nebeneffekt einer Anwendung Dateien in iTunes, die oft unbeabsichtigte, speziell für Anwendungen, die viele kleine Dateien behandeln war, sichtbar zu machen, anstatt komplette Dokumente für den Export, die den beabsichtigten Zweck des Verzeichnisses ist zu produzieren.
+
+Es ist jetzt möglich, ob Sie Dateien in Dokumente oder Verzeichnis Library mit einer Präferenz in der Anwendung-config.xml-Datei speichern möchten. Hierzu fügen Sie eine dieser zwei Zeilen zu "config.xml":
+
+ <preference name="iosPersistentFileLocation" value="Library" />
+
+ <preference name="iosPersistentFileLocation" value="Compatibility" />
+
+
+Ohne diese Zeile wird die Datei-Erweiterung "Kompatibilität" als Standard verwenden. Wenn ein Präferenz-Tag vorhanden ist, und nicht einen der folgenden Werte, wird die Anwendung nicht gestartet.
+
+Wenn Ihre Anwendung für Benutzer zuvor versandt wird, mithilfe eines älteren (Pre-1.0) Version dieses Plugins und gespeicherte Dateien im permanenten Dateisystem hat, dann setzen Sie die Einstellung auf "Kompatibilität". Wechseln zu "Library" Position würde bedeuten, dass Benutzer, die ihre Anwendung aktualisieren nicht in der Lage wäre, ihre zuvor gespeicherte Dateien zugreifen.
+
+Wenn die Anwendung neu, oder nie zuvor Dateien im Dateisystem persistent gespeichert hat, wird die Einstellung "Bibliothek" empfohlen.
+
+### Firefox OS Macken
+
+Der Datei-System-API wird von Firefox-OS nicht nativ unterstützt und wird als ein Shim auf IndexedDB implementiert.
+
+* Schlägt nicht fehl, wenn Sie nicht leere Verzeichnisse entfernen
+* Metadaten wird für Verzeichnisse nicht unterstützt.
+* Bietet keine Unterstützung für `requestAllFileSystems` und `resolveLocalFileSystemURI` Methoden
+* Methoden `copyTo` und `moveTo` unterstützen keine Verzeichnisse
+
+## Upgrade Notes
+
+In v1.0.0 des Plugins die `FileEntry` und `DirectoryEntry` Strukturen haben sich geändert, um mehr im Einklang mit der veröffentlichten Spezifikation zu sein.
+
+Vorgängerversionen (Pre-1.0.0) des Plugins gespeichert den Gerät-Absolute-Dateispeicherort in der `fullPath` -Eigenschaft der `Entry` Objekte. Diese Pfade würde in der Regel aussehen
+
+ /var/mobile/Applications/<application UUID>/Documents/path/to/file (iOS)
+ /storage/emulated/0/path/to/file (Android)
+
+
+Diese Pfade wurden auch zurückgegeben, indem die `toURL()` -Methode des der `Entry` Objekte.
+
+Mit v1.0.0 das `fullPath` -Attribut ist der Pfad zu der Datei, *relativ zum Stammverzeichnis des Dateisystems HTML*. Also die oben genannten Pfade würden jetzt beide durch dargestellt werden ein `FileEntry` -Objekt mit einer `fullPath` von
+
+ /path/to/file
+
+
+Wenn Ihre Anwendung mit absoluter Gerätepfade arbeitet und Sie zuvor diese Pfade durch abgerufenen die `fullPath` -Eigenschaft des `Entry` Objekte, dann Sie Ihren Code mithilfe von update sollte `entry.toURL()` statt.
+
+Für rückwärts Kompatibilität, die `resolveLocalFileSystemURL()` -Methode akzeptiert einen Absolute-Gerätepfad und kehren ein `Entry` -Objekt entspricht, solange diese Datei innerhalb von vorübergehenden oder dauerhaften Dateisysteme existiert.
+
+Dies wurde vor allem ein Problem mit dem File-Transfer-Plugin, die zuvor-Absolute-Gerätepfade verwendet (und kann damit noch einverstanden). Es wurde aktualisiert, um ordnungsgemäß mit Dateisystem-URLs, so anstelle `entry.fullPath` mit `entry.toURL()` sollte lösen Sie alle Probleme, die immer des Plugin zum Arbeiten mit Dateien auf dem Gerät.
+
+In v1.1.0 der Rückgabewert der `toURL()` wurde geändert (siehe \[CB-6394\] (https://issues.apache.org/jira/browse/CB-6394)), um eine absolute "file://" URL zurückgeben. wo immer möglich. Sicherstellung einer ' Cdvfile:'-URL Sie können `toInternalURL()` jetzt. Diese Methode gibt jetzt Dateisystem URLs der Form zurück.
+
+ cdvfile://localhost/persistent/path/to/file
+
+
+die benutzt werden können, um die Datei eindeutig zu identifizieren.
+
+## Liste der Fehlercodes und Bedeutungen
+
+Wenn ein Fehler ausgelöst wird, wird eines der folgenden Codes verwendet werden.
+
+* 1 = NOT\_FOUND\_ERR
+* 2 = SECURITY_ERR
+* 3 = ABORT_ERR
+* 4 = NOT\_READABLE\_ERR
+* 5 = ENCODING_ERR
+* 6 = NO\_MODIFICATION\_ALLOWED_ERR
+* 7 = INVALID\_STATE\_ERR
+* 8 = SYNTAX_ERR
+* 9 = INVALID\_MODIFICATION\_ERR
+* 10 = QUOTA\_EXCEEDED\_ERR
+* 11 = TYPE\_MISMATCH\_ERR
+* 12 = PATH\_EXISTS\_ERR
+
+## Konfigurieren das Plugin (Optional)
+
+Die Menge der verfügbaren Dateisysteme kann pro Plattform konfiguriert sein. Erkennen von iOS und Android ein <preference> -Tag im `config.xml` die Namen der Dateisysteme installiert werden. Standardmäßig sind alle Datei-System-Roots aktiviert.
+
+ <preference name="iosExtraFilesystems" value="library,library-nosync,documents,documents-nosync,cache,bundle,root" />
+ <preference name="AndroidExtraFilesystems" value="files,files-external,documents,sdcard,cache,cache-external,root" />
+
+
+### Android
+
+* Dateien: interne Datei-Speicher-Verzeichnis der Anwendung
+* Dateien-extern: Verzeichnis der Anwendung externe Datei Speicher
+* Sdcard: das externe Globaldatei-Speicherverzeichnis (Dies ist die Wurzel der SD-Karte, sofern installiert). Sie müssen die `android.permission.WRITE_EXTERNAL_STORAGE` Erlaubnis, diese zu verwenden.
+* Cache: internen Cache-Verzeichnis der Anwendung
+* Cache-extern: externer Cache-Verzeichnis der Anwendung
+* Wurzel: das gesamte Gerät-Dateisystem
+
+Android unterstützt auch eine spezielle Dateisystem mit dem Namen "Dokumente", die ein Unterverzeichnis "/ Dokumente /" die "Dateien" Dateisystem darstellt.
+
+### iOS
+
+* Bibliothek: Bibliothek-Verzeichnis der Anwendung
+* Dokumente: Dokumente-Verzeichnis der Anwendung
+* Cache: Cache-Verzeichnis der Anwendung
+* Bundle: die Anwendung Bündel; den Speicherort der die app selbst auf dem Datenträger (schreibgeschützt)
+* Wurzel: das gesamte Gerät-Dateisystem
+
+Standardmäßig können die Bibliothek und Dokumenten-Verzeichnisse mit iCloud synchronisiert werden. Sie können auch beantragen, zwei zusätzliche Dateisysteme, "Bibliothek-Nosync" und "Dokumente-Nosync", die einem speziellen nicht synchronisierten Verzeichnis im Dateisystem Bibliothek oder Dokumente darstellen.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-plugin-file/blob/05e393dd/doc/de/plugins.md
----------------------------------------------------------------------
diff --git a/doc/de/plugins.md b/doc/de/plugins.md
new file mode 100644
index 0000000..1f4297f
--- /dev/null
+++ b/doc/de/plugins.md
@@ -0,0 +1,124 @@
+<!---
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+
+# Hinweise für Plugin-Entwickler
+
+Diese Notizen sollen in erster Linie für Android und iOS-Entwickler, die Plugins welche Schnittstelle mit dem Dateisystem, mit dem Datei-Plugin schreiben möchten.
+
+## Arbeiten mit Cordova-Datei-System-URLs
+
+Seit der Version 1.0.0, wurde dieses Plugin URLs mit verwendet eine `cdvfile` Regelung für die gesamte Kommunikation über die Brücke, sondern als raw-Device Dateisystempfade zu JavaScript auszusetzen.
+
+Auf der Seite JavaScript bedeutet dies, dass FileEntries und DirectoryEntry-Objekt ein FullPath-Attribut haben, die relativ zum Stammverzeichnis des Dateisystems HTML ist. Wenn Ihr Plugins-JavaScript-API ein FileEntries oder DirectoryEntry-Objekt akzeptiert, rufen Sie `.toURL()` auf das Objekt vor der Übergabe an systemeigenen Code über die Brücke.
+
+### Konvertieren von Cdvfile: / / URLs auf Fileystem Pfade
+
+Plugins, die auf das Dateisystem schreiben müssen, möchten möglicherweise eine empfangene Datei-System-URL auf eine tatsächliche Stelle des Dateisystems zu konvertieren. Es gibt mehrere Wege, dies zu tun, je nach einheitlichen Plattform.
+
+Es ist wichtig zu erinnern, dass nicht alle `cdvfile://` URLs sind zuweisbaren real Dateien auf das Gerät. Einige URLs verweisen auf Vermögenswerte auf Gerät die werden nicht durch Dateien dargestellt, oder sogar auf Remoteressourcen verweisen kann. Aufgrund dieser Möglichkeiten sollten Plugins immer testen, ob sie ein sinnvolles Ergebnis zu erhalten, wieder beim URLs in Pfade umwandeln.
+
+#### Android
+
+Auf Android, die einfachste Methode zum Konvertieren eines `cdvfile://` darin, dass die URL zu einem Dateisystempfad verwenden `org.apache.cordova.CordovaResourceApi` . `CordovaResourceApi`verfügt über mehrere Methoden der verarbeiten kann `cdvfile://` URLs:
+
+ // webView is a member of the Plugin class
+ CordovaResourceApi resourceApi = webView.getResourceApi();
+
+ // Obtain a file:/// URL representing this file on the device,
+ // or the same URL unchanged if it cannot be mapped to a file
+ Uri fileURL = resourceApi.remapUri(Uri.parse(cdvfileURL));
+
+
+Es ist auch möglich, das Plugin Datei direkt zu verwenden:
+
+ import org.apache.cordova.file.FileUtils;
+ import org.apache.cordova.file.FileSystem;
+ import java.net.MalformedURLException;
+
+ // Get the File plugin from the plugin manager
+ FileUtils filePlugin = (FileUtils)webView.pluginManager.getPlugin("File");
+
+ // Given a URL, get a path for it
+ try {
+ String path = filePlugin.filesystemPathForURL(cdvfileURL);
+ } catch (MalformedURLException e) {
+ // The filesystem url wasn't recognized
+ }
+
+
+Konvertieren von einen Pfad zu einer `cdvfile://` URL:
+
+ import org.apache.cordova.file.LocalFilesystemURL;
+
+ // Get a LocalFilesystemURL object for a device path,
+ // or null if it cannot be represented as a cdvfile URL.
+ LocalFilesystemURL url = filePlugin.filesystemURLforLocalPath(path);
+ // Get the string representation of the URL object
+ String cdvfileURL = url.toString();
+
+
+Wenn Ihr Plugin eine Datei erstellt, und Sie dafür ein FileEntries-Objekt zurückgeben möchten, verwenden Sie das Datei-Plugin:
+
+ // Return a JSON structure suitable for returning to JavaScript,
+ // or null if this file is not representable as a cdvfile URL.
+ JSONObject entry = filePlugin.getEntryForFile(file);
+
+
+#### iOS
+
+Cordova auf iOS verwendet nicht das gleiche `CordovaResourceApi` Konzept als Android. Auf iOS sollten Sie das Datei-Plugin verwenden, zum Konvertieren von URLs und Dateisystem-Pfaden.
+
+ // Get a CDVFilesystem URL object from a URL string
+ CDVFilesystemURL* url = [CDVFilesystemURL fileSystemURLWithString:cdvfileURL];
+ // Get a path for the URL object, or nil if it cannot be mapped to a file
+ NSString* path = [filePlugin filesystemPathForURL:url];
+
+
+ // Get a CDVFilesystem URL object for a device path, or
+ // nil if it cannot be represented as a cdvfile URL.
+ CDVFilesystemURL* url = [filePlugin fileSystemURLforLocalPath:path];
+ // Get the string representation of the URL object
+ NSString* cdvfileURL = [url absoluteString];
+
+
+Wenn Ihr Plugin eine Datei erstellt, und Sie dafür ein FileEntries-Objekt zurückgeben möchten, verwenden Sie das Datei-Plugin:
+
+ // Get a CDVFilesystem URL object for a device path, or
+ // nil if it cannot be represented as a cdvfile URL.
+ CDVFilesystemURL* url = [filePlugin fileSystemURLforLocalPath:path];
+ // Get a structure to return to JavaScript
+ NSDictionary* entry = [filePlugin makeEntryForLocalURL:url]
+
+
+#### JavaScript
+
+In JavaScript, bekommen eine `cdvfile://` URL aus einem FileEntries oder DirectoryEntry-Objekt, rufen Sie einfach `.toURL()` drauf:
+
+ var cdvfileURL = entry.toURL();
+
+
+Im Plugin Antwort Handler um aus einer zurückgegebenen FileEntries-Struktur in ein tatsächliches Entry-Objekt zu konvertieren sollte Handlercode importieren die Datei-Erweiterung und ein neues Objekt erstellen:
+
+ // create appropriate Entry object
+ var entry;
+ if (entryStruct.isDirectory) {
+ entry = new DirectoryEntry(entryStruct.name, entryStruct.fullPath, new FileSystem(entryStruct.filesystemName));
+ } else {
+ entry = new FileEntry(entryStruct.name, entryStruct.fullPath, new FileSystem(entryStruct.filesystemName));
+ }
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-plugin-file/blob/05e393dd/doc/es/index.md
----------------------------------------------------------------------
diff --git a/doc/es/index.md b/doc/es/index.md
new file mode 100644
index 0000000..4d6ddf2
--- /dev/null
+++ b/doc/es/index.md
@@ -0,0 +1,201 @@
+<!---
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+
+# org.apache.cordova.file
+
+Este plugin proporciona la [API del sistema de ficheros de HTML5][1]. Para el uso, consulte [FileSystem artículo][2] sobre el tema HTML5 rocas. Para tener una visión general de otras opciones de almacenamiento, consulte [Guía de almacenamiento Cordova][3].
+
+ [1]: http://dev.w3.org/2009/dap/file-system/pub/FileSystem/
+ [2]: http://www.html5rocks.com/en/tutorials/file/filesystem/
+ [3]: http://cordova.apache.org/docs/en/edge/cordova_storage_storage.md.html
+
+## Instalación
+
+ cordova plugin add org.apache.cordova.file
+
+
+## Plataformas soportadas
+
+* Amazon fuego OS
+* Android
+* BlackBerry 10
+* iOS
+* Windows Phone 7 y 8 *
+* Windows 8 *
+* Firefox OS
+
+* *No son compatibles con estas plataformas `FileReader.readAsArrayBuffer` ni `FileWriter.write(blob)` .*
+
+## Donde almacenar los archivos
+
+A partir de v1.2.0, URLs a directorios de sistema de archivos importantes son proporcionadas. Cada dirección URL está en la forma *file:///path/to/spot/*y se puede convertir en un `DirectoryEntry` usando`window.resolveLocalFileSystemURL()`.
+
+`cordova.file.applicationDirectory`-Directorio Read-only donde está instalada la aplicación. (*iOS*, *Android*)
+
+`cordova.file.applicationStorageDirectory`-Raíz de almacenamiento escribible privado de app. (*iOS*, *Android*)
+
+`cordova.file.dataDirectory`¿Dónde poner los archivos de datos específicos de la aplicación. (*iOS*, *Android*)
+
+`cordova.file.cacheDirectory`-Almacena en caché los archivos que deben sobrevivir se reinicia la aplicación. Aplicaciones no deben confiar en el sistema operativo para eliminar los archivos de aquí. (*iOS*, *Android*)
+
+`cordova.file.externalApplicationStorageDirectory`-Espacio aplicación de almacenamiento externo. (*iOS*, *Android*)
+
+`cordova.file.externalDataDirectory`¿Dónde poner los archivos de datos específicos de la aplicación de almacenamiento externo. (*Android*)
+
+`cordova.file.externalCacheDirectory`-Caché aplicación de almacenamiento externo. (*Android*)
+
+`cordova.file.externalRootDirectory`-Raíz de almacenamiento externo (tarjeta SD). (*Android*)
+
+`cordova.file.tempDirectory`-Directorio temporal que puede borrar el sistema operativo en sí. (*iOS*)
+
+`cordova.file.syncedDataDirectory`-Contiene los archivos de la aplicación específica que deben ser sincronizados (e.g. a iCloud). (*iOS*)
+
+`cordova.file.documentsDirectory`-Archivos privados a la aplicación, pero que son significativos para otros applciations (por ejemplo archivos de Office). (*iOS*)
+
+## Rarezas Android
+
+### Ubicación de almacenamiento persistente Android
+
+Hay múltiples ubicaciones válidas para almacenar archivos persistentes en un dispositivo Android. Vea [esta página][4] para una extensa discusión de las distintas posibilidades.
+
+ [4]: http://developer.android.com/guide/topics/data/data-storage.html
+
+Las versiones anteriores del plugin elegiría la ubicación de los archivos temporales y persistentes en el arranque, basado en si el dispositivo afirmó que fue montado en la tarjeta SD (o partición de almacenamiento equivalente). Si fue montada en la tarjeta SD, o una partición de gran almacenamiento interno estaba disponible (como en dispositivos de Nexus,) y luego los archivos persistentes se almacenaría en la raíz de ese espacio. Esto significaba que todas las apps Cordova podían ver todos los archivos disponibles en la tarjeta.
+
+Si la tarjeta SD no estaba disponible, entonces las versiones anteriores almacenará datos bajo /data/data /<packageid>, que aísla las apps del otro, pero todavía puede causar datos ser compartido entre los usuarios.
+
+Ahora es posible elegir si desea almacenar archivos en la ubicación de almacenamiento del archivo interno, o usando la lógica anterior, con preferencia en el archivo config.xml de su aplicación. Para ello, añada una de estas dos líneas en config.xml:
+
+ <preference name="AndroidPersistentFileLocation" value="Internal" />
+
+ <preference name="AndroidPersistentFileLocation" value="Compatibility" />
+
+
+Sin esta línea, el archivo plugin utilizará "Compatibilidad" como el valor por defecto. Si una etiqueta de preferencia está presente y no es uno de estos valores, no se iniciará la aplicación.
+
+Si su solicitud se ha enviado previamente a los usuarios, mediante una mayor (1.0 pre) versión de este plugin y archivos almacenados en el sistema de ficheros persistente, entonces se debe establecer la preferencia a la "Compatibilidad". Cambiar la ubicación para "Internal" significa que los usuarios existentes que actualización su aplicación pueden ser incapaces de acceder a sus archivos previamente almacenadas, dependiendo de su dispositivo.
+
+Si su solicitud es nueva, o nunca antes ha almacenado archivos en el sistema de ficheros persistente, el ajuste "interno" se recomienda generalmente.
+
+## iOS rarezas
+
+* `FileReader.readAsText(blob, encoding)`
+ * El `encoding` no se admite el parámetro, y codificación UTF-8 es siempre en efecto.
+
+### iOS ubicación de almacenamiento persistente
+
+Hay dos ubicaciones válidas para almacenar archivos persistentes en un dispositivo iOS: el directorio de documentos y el directorio de biblioteca. Las versiones anteriores del plugin sólo almacenan archivos persistentes en el directorio de documentos. Esto tenía el efecto secundario de todos los archivos de la aplicación haciendo visible en iTunes, que era a menudo involuntarios, especialmente para aplicaciones que manejan gran cantidad de archivos pequeños, en lugar de producir documentos completos para la exportación, que es la finalidad del directorio.
+
+Ahora es posible elegir si desea almacenar archivos en los documentos o directorio de bibliotecas, con preferencia en el archivo config.xml de su aplicación. Para ello, añada una de estas dos líneas en config.xml:
+
+ <preference name="iosPersistentFileLocation" value="Library" />
+
+ <preference name="iosPersistentFileLocation" value="Compatibility" />
+
+
+Sin esta línea, el archivo plugin utilizará "Compatibilidad" como el valor por defecto. Si una etiqueta de preferencia está presente y no es uno de estos valores, no se iniciará la aplicación.
+
+Si su solicitud se ha enviado previamente a los usuarios, mediante una mayor (1.0 pre) versión de este plugin y archivos almacenados en el sistema de ficheros persistente, entonces se debe establecer la preferencia a la "Compatibilidad". Cambiar la ubicación a la "Biblioteca" significa que los usuarios existentes que actualización su aplicación sería incapaces de acceder a sus archivos previamente almacenadas.
+
+Si su solicitud es nueva, o nunca antes ha almacenado archivos en el sistema de ficheros persistente, el ajuste de "Biblioteca" generalmente se recomienda.
+
+### Firefox OS rarezas
+
+La API de sistema de archivo de forma nativa no es compatible con Firefox OS y se implementa como una cuña en la parte superior indexedDB.
+
+* No falla cuando eliminar directorios no vacía
+* No admite metadatos para directorios
+* No es compatible con `requestAllFileSystems` y `resolveLocalFileSystemURI` métodos
+* Los métodos `copyTo` y `moveTo` no son compatibles con directorios
+
+## Actualización de notas
+
+En v1.0.0 de este plugin, la `FileEntry` y `DirectoryEntry` han cambiado las estructuras, para estar más acorde con las especificaciones publicadas.
+
+Versiones anteriores (pre-1.0.0) del plugin almacenan el dispositivo-absoluto-archivo-ubicación en la `fullPath` propiedad de `Entry` objetos. Estos caminos típicamente parecería
+
+ /var/mobile/Applications/<application UUID>/Documents/path/to/file (iOS)
+ /storage/emulated/0/path/to/file (Android)
+
+
+Estas rutas también fueron devueltos por el `toURL()` método de la `Entry` objetos.
+
+Con v1.0.0, la `fullPath` es la ruta del archivo, *relativo a la raíz del sistema de archivos HTML*. Así, los caminos anteriores que ahora ambos ser representado por un `FileEntry` objeto con un `fullPath` de
+
+ /path/to/file
+
+
+Si su aplicación funciona con dispositivo-absoluto-caminos, y previamente obtenido esos caminos a través de la `fullPath` propiedad de `Entry` objetos, entonces debe actualizar su código para utilizar `entry.toURL()` en su lugar.
+
+Para atrás compatibilidad, el `resolveLocalFileSystemURL()` método aceptará un dispositivo-absoluto-trayectoria y volverá un `Entry` objeto correspondiente, mientras exista ese archivo dentro de los sistemas de ficheros temporales o permanentes.
+
+Esto ha sido particularmente un problema con el plugin de transferencia de archivos, que anteriormente utilizado dispositivo-absoluto-caminos (y todavía puede aceptarlas). Se ha actualizado para que funcione correctamente con las URLs de FileSystem, reemplazando así `entry.fullPath` con `entry.toURL()` debe resolver cualquier problema conseguir ese plugin para trabajar con archivos en el dispositivo.
+
+En v1.1.0 el valor devuelto de `toURL()` fue cambiado (véase \[CB-6394\] (https://issues.apache.org/jira/browse/CB-6394)) para devolver una dirección URL absoluta 'file://'. siempre que sea posible. Para asegurar una ' cdvfile:'-URL puede usar `toInternalURL()` ahora. Este método devolverá ahora filesystem URLs de la forma
+
+ cdvfile://localhost/persistent/path/to/file
+
+
+que puede utilizarse para identificar el archivo únicamente.
+
+## Lista de códigos de Error y significados
+
+Cuando se produce un error, uno de los siguientes códigos se utilizará.
+
+* 1 = NOT\_FOUND\_ERR
+* 2 = SECURITY_ERR
+* 3 = ABORT_ERR
+* 4 = NOT\_READABLE\_ERR
+* 5 = ENCODING_ERR
+* 6 = NO\_MODIFICATION\_ALLOWED_ERR
+* 7 = INVALID\_STATE\_ERR
+* 8 = SYNTAX_ERR
+* 9 = INVALID\_MODIFICATION\_ERR
+* 10 = QUOTA\_EXCEEDED\_ERR
+* 11 = TYPE\_MISMATCH\_ERR
+* 12 = PATH\_EXISTS\_ERR
+
+## Configurando el Plugin (opcional)
+
+El conjunto de los sistemas de ficheros disponibles puede ser configurado por plataforma. Tanto iOS y Android reconocen un <preference> etiqueta en `config.xml` que nombra a los sistemas de archivos para ser instalado. De forma predeterminada, se activan todas las raíces del sistema de archivos.
+
+ <preference name="iosExtraFilesystems" value="library,library-nosync,documents,documents-nosync,cache,bundle,root" />
+ <preference name="AndroidExtraFilesystems" value="files,files-external,documents,sdcard,cache,cache-external,root" />
+
+
+### Android
+
+* archivos: directorio de almacenamiento de archivo interno de la aplicación
+* archivos externos: directorio de almacenamiento de archivo externo de la aplicación
+* sdcard: el directorio de almacenamiento de archivo externo global (esta es la raíz de la tarjeta SD, si uno está instalado). Debes tener el `android.permission.WRITE_EXTERNAL_STORAGE` permiso para usar esto.
+* memoria caché: directorio de memoria caché interna de la aplicación
+* caché-externo: directorio de caché externo de la aplicación
+* raíz: el sistema de archivos de todo el dispositivo
+
+Android también es compatible con un sistema de archivos especial llamado "documentos", que representa un subdirectorio "/ documentos /" dentro del sistema de archivos "archivos".
+
+### iOS
+
+* Biblioteca: directorio de bibliotecas de la aplicación
+* documentos: directorio de documentos de la aplicación
+* memoria caché: directorio de caché de la aplicación
+* paquete: paquete de la aplicación; la ubicación de la aplicación en sí mismo en el disco (sólo lectura)
+* raíz: el sistema de archivos de todo el dispositivo
+
+De forma predeterminada, los directorios de documentos y la biblioteca pueden ser sincronizados con iCloud. También puede solicitar dos sistemas adicionales, "biblioteca-nosync" y "documentos-nosync", que representan un directorio no-sincronizado especial dentro del sistema de ficheros de biblioteca o documentos.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-plugin-file/blob/05e393dd/doc/es/plugins.md
----------------------------------------------------------------------
diff --git a/doc/es/plugins.md b/doc/es/plugins.md
new file mode 100644
index 0000000..fd126fc
--- /dev/null
+++ b/doc/es/plugins.md
@@ -0,0 +1,124 @@
+<!---
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+
+# Notas para los desarrolladores de plugin
+
+Estas notas están pensadas principalmente para los desarrolladores de Android y el iOS que quieran escribir plugins que interfaz con el sistema de archivos usando el plugin de archivo.
+
+## Trabajando con Cordova archivo sistema URLs
+
+Desde la versión 1.0.0, este plugin utiliza las direcciones URL con un `cdvfile` plan para todas las comunicaciones sobre el puente, en lugar de exponer rutas de sistema de archivo de dispositivo raw a JavaScript.
+
+En el lado de JavaScript, esto significa que los objetos FileEntry y DirectoryEntry tienen un atributo fullPath que es relativo a la raíz del sistema de archivos HTML. Si JavaScript API del plugin acepta un objeto FileEntry o DirectoryEntry, debe llamar a `.toURL()` en ese objeto antes de pasarla a través del puente a código nativo.
+
+### Conversión de cdvfile: / / URL al fileystem caminos
+
+Plugins que necesita escribir en el sistema de archivos puede querer convertir un archivo recibido sistema URL a una ubicación de archivos reales. Hay varias formas de hacer esto, dependiendo de la plataforma nativa.
+
+Es importante recordar que no todos `cdvfile://` URLs son asignables a los archivos reales en el dispositivo. Algunas URLs pueden referirse a activos en dispositivos que no están representados por los archivos, o incluso pueden referirse a recursos remotos. Debido a estas posibilidades, plugins siempre debe probar si consiguen un resultado significativo cuando tratando de convertir URLs en trazados.
+
+#### Android
+
+En Android, el método más sencillo para convertir un `cdvfile://` URL a una ruta de sistema de archivos es utilizar `org.apache.cordova.CordovaResourceApi` . `CordovaResourceApi`tiene varios métodos que pueden manejar `cdvfile://` URLs:
+
+ // webView is a member of the Plugin class
+ CordovaResourceApi resourceApi = webView.getResourceApi();
+
+ // Obtain a file:/// URL representing this file on the device,
+ // or the same URL unchanged if it cannot be mapped to a file
+ Uri fileURL = resourceApi.remapUri(Uri.parse(cdvfileURL));
+
+
+También es posible utilizar directamente el archivo plugin:
+
+ import org.apache.cordova.file.FileUtils;
+ import org.apache.cordova.file.FileSystem;
+ import java.net.MalformedURLException;
+
+ // Get the File plugin from the plugin manager
+ FileUtils filePlugin = (FileUtils)webView.pluginManager.getPlugin("File");
+
+ // Given a URL, get a path for it
+ try {
+ String path = filePlugin.filesystemPathForURL(cdvfileURL);
+ } catch (MalformedURLException e) {
+ // The filesystem url wasn't recognized
+ }
+
+
+Para convertir de un camino hacia un `cdvfile://` URL:
+
+ import org.apache.cordova.file.LocalFilesystemURL;
+
+ // Get a LocalFilesystemURL object for a device path,
+ // or null if it cannot be represented as a cdvfile URL.
+ LocalFilesystemURL url = filePlugin.filesystemURLforLocalPath(path);
+ // Get the string representation of the URL object
+ String cdvfileURL = url.toString();
+
+
+Si tu plugin crea un archivo y desea devolver un objeto FileEntry para ello, utilice el archivo plugin:
+
+ // Return a JSON structure suitable for returning to JavaScript,
+ // or null if this file is not representable as a cdvfile URL.
+ JSONObject entry = filePlugin.getEntryForFile(file);
+
+
+#### iOS
+
+Cordova en iOS no utiliza el mismo `CordovaResourceApi` concepto como Android. En iOS, utilice el archivo plugin para convertir las direcciones URL y rutas de archivos.
+
+ // Get a CDVFilesystem URL object from a URL string
+ CDVFilesystemURL* url = [CDVFilesystemURL fileSystemURLWithString:cdvfileURL];
+ // Get a path for the URL object, or nil if it cannot be mapped to a file
+ NSString* path = [filePlugin filesystemPathForURL:url];
+
+
+ // Get a CDVFilesystem URL object for a device path, or
+ // nil if it cannot be represented as a cdvfile URL.
+ CDVFilesystemURL* url = [filePlugin fileSystemURLforLocalPath:path];
+ // Get the string representation of the URL object
+ NSString* cdvfileURL = [url absoluteString];
+
+
+Si tu plugin crea un archivo y desea devolver un objeto FileEntry para ello, utilice el archivo plugin:
+
+ // Get a CDVFilesystem URL object for a device path, or
+ // nil if it cannot be represented as a cdvfile URL.
+ CDVFilesystemURL* url = [filePlugin fileSystemURLforLocalPath:path];
+ // Get a structure to return to JavaScript
+ NSDictionary* entry = [filePlugin makeEntryForLocalURL:url]
+
+
+#### JavaScript
+
+En JavaScript, para conseguir un `cdvfile://` URL de un objeto FileEntry o DirectoryEntry, simplemente llame a `.toURL()` en él:
+
+ var cdvfileURL = entry.toURL();
+
+
+En plugin manipuladores de respuesta, para convertir de una estructura FileEntry devuelta a un objeto real de la entrada, el código del controlador debe importar el archivo plugin y crear un nuevo objeto:
+
+ // create appropriate Entry object
+ var entry;
+ if (entryStruct.isDirectory) {
+ entry = new DirectoryEntry(entryStruct.name, entryStruct.fullPath, new FileSystem(entryStruct.filesystemName));
+ } else {
+ entry = new FileEntry(entryStruct.name, entryStruct.fullPath, new FileSystem(entryStruct.filesystemName));
+ }
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-plugin-file/blob/05e393dd/doc/fr/index.md
----------------------------------------------------------------------
diff --git a/doc/fr/index.md b/doc/fr/index.md
new file mode 100644
index 0000000..a460d6e
--- /dev/null
+++ b/doc/fr/index.md
@@ -0,0 +1,201 @@
+<!---
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+
+# org.apache.cordova.file
+
+Ce plugin fournit les [API de système de fichiers de HTML5][1]. Pour son utilisation, reportez-vous à l'HTML5 Rocks' [FileSystem article][2] sur le sujet. Pour un aperçu des autres options de stockage, consultez [guide d'entreposage de Cordova][3].
+
+ [1]: http://dev.w3.org/2009/dap/file-system/pub/FileSystem/
+ [2]: http://www.html5rocks.com/en/tutorials/file/filesystem/
+ [3]: http://cordova.apache.org/docs/en/edge/cordova_storage_storage.md.html
+
+## Installation
+
+ cordova plugin add org.apache.cordova.file
+
+
+## Plates-formes prises en charge
+
+* Amazon Fire OS
+* Android
+* BlackBerry 10
+* iOS
+* Windows Phone 7 et 8 *
+* Windows 8 *
+* Firefox OS
+
+* *Ces plates-formes ne supportent pas `FileReader.readAsArrayBuffer` ni `FileWriter.write(blob)` .*
+
+## Emplacement de stockage des fichiers
+
+À partir de v1.2.0, URL vers des répertoires de système de fichiers importants est fournis. Chaque URL est dans la forme *file:///path/to/spot/*et peut être converti en un `DirectoryEntry` à l'aide`window.resolveLocalFileSystemURL()`.
+
+`cordova.file.applicationDirectory`-Lecture seule répertoire où l'application est installée. (*iOS*, *Android*)
+
+`cordova.file.applicationStorageDirectory`-Racine de stockage accessible en écriture privé de l'application. (*iOS*, *Android*)
+
+`cordova.file.dataDirectory`-Où placer les fichiers de données d'application spécifiques. (*iOS*, *Android*)
+
+`cordova.file.cacheDirectory`-Mise en cache de fichiers qui doivent survivre app redémarre. Apps ne doivent pas compter sur le système d'exploitation pour supprimer les fichiers ici. (*iOS*, *Android*)
+
+`cordova.file.externalApplicationStorageDirectory`-Espace l'application sur le stockage externe. (*iOS*, *Android*)
+
+`cordova.file.externalDataDirectory`-Où placer les fichiers de données d'application spécifiques sur le stockage externe. (*Android*)
+
+`cordova.file.externalCacheDirectory`-Cache de l'application sur le stockage externe. (*Android*)
+
+`cordova.file.externalRootDirectory`-Racine de stockage externe (carte SD). (*Android*)
+
+`cordova.file.tempDirectory`-Répertoire temp que l'OS peut effacer à volonté. (*iOS*)
+
+`cordova.file.syncedDataDirectory`-Contient des fichiers d'app spécifique qui doivent se synchroniser (par exemple à iCloud). (*iOS*)
+
+`cordova.file.documentsDirectory`-Fichiers privés à l'app, mais qui sont utiles à d'autres applications (par exemple les fichiers Office). (*iOS*)
+
+## Quirks Android
+
+### Emplacement de stockage persistant Android
+
+Il y a plusieurs emplacements valides pour stocker des fichiers persistants sur un appareil Android. Voir [cette page][4] pour une analyse approfondie des diverses possibilités.
+
+ [4]: http://developer.android.com/guide/topics/data/data-storage.html
+
+Les versions précédentes du plugin choisirait l'emplacement des fichiers temporaires et persistantes au démarrage, basé sur la question de savoir si le dispositif réclamé que la carte SD (ou une partition de stockage équivalent) a été montée. Si la carte SD a été montée, ou si une partition de stockage interne importante était disponible (comme sur les appareils Nexus,) puis les fichiers persistants seraient stockés dans la racine de cet espace. Cela signifie que toutes les apps de Cordova pouvaient voir tous les fichiers disponibles sur la carte.
+
+Si la carte SD n'était pas disponible, alors les versions précédentes seraient stocker des données sous/données/data /<packageid>, qui isole les apps de l'autre, mais peuvent encore provoquer des données à partager entre les utilisateurs.
+
+Il est maintenant possible de choisir de stocker les fichiers dans l'emplacement de stockage de fichier interne, ou en utilisant la logique précédente, avec une préférence dans le fichier config.xml de votre application. Pour ce faire, ajoutez l'un des ces deux lignes au fichier config.xml :
+
+ <preference name="AndroidPersistentFileLocation" value="Internal" />
+
+ <preference name="AndroidPersistentFileLocation" value="Compatibility" />
+
+
+Sans cette ligne, le fichier plugin utilisera la valeur par défaut « Compatibilité ». Si une balise de préférence est présente et n'est pas une des valeurs suivantes, l'application ne démarrera pas.
+
+Si votre application a déjà été expédiée aux utilisateurs, en utilisant une ancienne (avant 1.0) version de ce plugin et dispose des fichiers stockés dans le système de fichiers persistant, alors vous devez définir la préférence à la « Compatibilité ». Commutation de l'emplacement « Internal » signifierait que les utilisateurs existants qui mettre à niveau leur application peuvent être impossible d'accéder à leurs fichiers déjà enregistrés, selon leur appareil.
+
+Si votre application est nouvelle ou a jamais précédemment stocké les fichiers dans le système de fichiers persistant, alors le paramètre « interne » est généralement recommandé.
+
+## iOS Quirks
+
+* `FileReader.readAsText(blob, encoding)`
+ * Le `encoding` paramètre n'est pas pris en charge, et le codage UTF-8 est toujours en vigueur.
+
+### emplacement de stockage persistant d'iOS
+
+Il y a deux emplacements valides pour stocker des fichiers persistants sur un appareil iOS : le répertoire de Documents et le répertoire de la bibliothèque. Les versions précédentes du plugin stockaient ne jamais fichiers persistants dans le répertoire de Documents. Cela a eu l'effet secondaire de rendre tous les fichiers de l'application visible dans iTunes, qui était souvent inattendus, en particulier pour les applications qui traitent beaucoup de petits fichiers, plutôt que de produire des documents complets destinés à l'exportation, qui est l'objectif visé par le répertoire.
+
+Il est maintenant possible de choisir de stocker les fichiers dans le répertoire de bibliothèque, avec une préférence dans le fichier config.xml de votre application ou de documents. Pour ce faire, ajoutez l'un des ces deux lignes au fichier config.xml :
+
+ <preference name="iosPersistentFileLocation" value="Library" />
+
+ <preference name="iosPersistentFileLocation" value="Compatibility" />
+
+
+Sans cette ligne, le fichier plugin utilisera la valeur par défaut « Compatibilité ». Si une balise de préférence est présente et n'est pas une des valeurs suivantes, l'application ne démarrera pas.
+
+Si votre application a déjà été expédiée aux utilisateurs, en utilisant une ancienne (avant 1.0) version de ce plugin et dispose des fichiers stockés dans le système de fichiers persistant, alors vous devez définir la préférence à la « Compatibilité ». L'emplacement de la « Bibliothèque » de commutation signifierait que les utilisateurs existants qui mettre à niveau leur application serait incapables d'accéder à leurs fichiers déjà enregistrés.
+
+Si votre application est nouvelle ou a jamais précédemment stocké les fichiers dans le système de fichiers persistant, alors le paramètre « Library » est généralement recommandé.
+
+### Firefox OS Quirks
+
+L'API de système de fichier n'est pas nativement pris en charge par Firefox OS et est implémentée comme une cale d'épaisseur sur le dessus d'indexedDB.
+
+* Ne manque pas lors de la suppression des répertoires non vide
+* Ne supporte pas les métadonnées pour les répertoires
+* Ne prend pas en charge `requestAllFileSystems` et `resolveLocalFileSystemURI` méthodes
+* Méthodes `copyTo` et `moveTo` ne prennent pas en charge les répertoires
+
+## Notes de mise à niveau
+
+Dans v1.0.0 de ce plugin, la `FileEntry` et `DirectoryEntry` structures ont changé, pour être plus conforme à la spécification publiée.
+
+Les versions précédentes de (pré-1.0.0) du plugin stockaient l'appareil-absolu-fichier-emplacement dans la `fullPath` propriété de `Entry` objets. Ces chemins seraient présente généralement comme
+
+ /var/mobile/Applications/<application UUID>/Documents/path/to/file (iOS)
+ /storage/emulated/0/path/to/file (Android)
+
+
+Ces chemins ont été également renvoyés par la `toURL()` méthode de la `Entry` des objets.
+
+Avec v1.0.0, le `fullPath` attribut contient le chemin vers le fichier, *par rapport à la racine du système de fichiers HTML*. Ainsi, les chemins d'accès ci-dessus seraient maintenant tous les deux être représenté par un `FileEntry` d'objet avec un `fullPath` de
+
+ /path/to/file
+
+
+Si votre application fonctionne avec le dispositif-absolu-chemins, et que vous avez récupéré précédemment ces chemins à travers la `fullPath` propriété de `Entry` objets, puis vous devez mettre à jour votre code d'utiliser `entry.toURL()` à la place.
+
+Pour vers l'arrière compatibilité, la `resolveLocalFileSystemURL()` méthode acceptera un chemin absolu de l'unité et retournera un `Entry` objet correspond, tant que ce fichier existe au sein des systèmes de fichiers temporaires ou permanents.
+
+Cela a été particulièrement un problème avec le plugin de transfert de fichiers, qui autrefois périphérique-absolu-chemins (et peut encore accepter). Il a été mis à jour pour fonctionner correctement avec des URL de système de fichiers, remplaçant ainsi `entry.fullPath` avec `entry.toURL()` devrait résoudre tout problème obtenir ce plugin pour travailler avec des fichiers sur le périphérique.
+
+Dans v1.1.0 la valeur de retour de `toURL()` a été changé (voir \[CB-6394\] (https://issues.apache.org/jira/browse/CB-6394)) pour renvoyer une URL absolue « file:// ». dans la mesure du possible. Pour assurer un ' cdvfile:'-URL, vous pouvez utiliser `toInternalURL()` maintenant. Cette méthode retourne maintenant filesystem URL du formulaire
+
+ cdvfile://localhost/persistent/path/to/file
+
+
+qui peut servir à identifier de manière unique le fichier.
+
+## Liste des Codes d'erreur et leur signification
+
+Lorsqu'une erreur est levée, l'un des codes suivants sera utilisé.
+
+* 1 = NOT\_FOUND\_ERR
+* 2 = SECURITY_ERR
+* 3 = ABORT_ERR
+* 4 = NOT\_READABLE\_ERR
+* 5 = ENCODING_ERR
+* 6 = NO\_MODIFICATION\_ALLOWED_ERR
+* 7 = INVALID\_STATE\_ERR
+* 8 = SYNTAX_ERR
+* 9 = INVALID\_MODIFICATION\_ERR
+* 10 = QUOTA\_EXCEEDED\_ERR
+* 11 = TYPE\_MISMATCH\_ERR
+* 12 = PATH\_EXISTS\_ERR
+
+## Configuration du Plugin (facultatif)
+
+L'ensemble des systèmes de fichiers disponibles peut être configurée par plate-forme. Les iOS et Android reconnaissent une <preference> tag dans `config.xml` qui désigne les systèmes de fichiers à installer. Par défaut, toutes les racines du système de fichiers sont activées.
+
+ <preference name="iosExtraFilesystems" value="library,library-nosync,documents,documents-nosync,cache,bundle,root" />
+ <preference name="AndroidExtraFilesystems" value="files,files-external,documents,sdcard,cache,cache-external,root" />
+
+
+### Android
+
+* fichiers : répertoire de stockage de fichier interne de l'application
+* fichiers externes : répertoire de l'application de stockage de fichier externe
+* carte SD : le répertoire de stockage global fichier externe (c'est la racine de la carte SD, s'il est installé). Vous devez avoir la `android.permission.WRITE_EXTERNAL_STORAGE` permission de l'utiliser.
+* cache : répertoire de cache interne de l'application
+* cache-externe : répertoire de cache externe de l'application
+* racine : le système de fichiers de tout dispositif
+
+Android prend également en charge un système de fichiers spécial nommé « documents », qui représente un sous-répertoire « / Documents / » dans le système de fichiers « files ».
+
+### iOS
+
+* Bibliothèque : répertoire de bibliothèque de l'application
+* documents : répertoire de Documents de l'application
+* cache : répertoire de Cache de l'application
+* Bundle : bundle de l'application ; l'emplacement de l'application elle-même sur disque (lecture seule)
+* racine : le système de fichiers de tout dispositif
+
+Par défaut, vous peuvent synchroniser les répertoires de la bibliothèque et les documents à iCloud. Vous pouvez également demander des deux systèmes de fichiers supplémentaires, « bibliothèque-nosync » et « documents-nosync », qui représentent un répertoire spécial non synchronisées dans le système de fichiers de bibliothèque ou de Documents.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-plugin-file/blob/05e393dd/doc/fr/plugins.md
----------------------------------------------------------------------
diff --git a/doc/fr/plugins.md b/doc/fr/plugins.md
new file mode 100644
index 0000000..070384e
--- /dev/null
+++ b/doc/fr/plugins.md
@@ -0,0 +1,124 @@
+<!---
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+
+# Notes pour les développeurs de plugins
+
+Ces notes sont principalement destinés à des développeurs Android et iOS qui veulent écrire des plugins qui interface avec le système de fichiers en utilisant le fichier plugin.
+
+## Travaillant avec des URL de système pour le fichier Cordova
+
+Depuis la version 1.0.0, ce plugin utilise des URL avec un `cdvfile` guichet pour toutes les communications sur le pont, plutôt que d'exposer les chemins de système de fichiers de périphérique brut à JavaScript.
+
+Du côté du JavaScript, cela signifie que les objets DirectoryEntry et de FileEntry ont un attribut fullPath qui est relatif à la racine du système de fichiers HTML. Si l'API JavaScript de votre plugin accepte un objet FileEntry ou DirectoryEntry, vous devez appeler `.toURL()` sur cet objet avant de le passer sur le pont en code natif.
+
+### Conversion des cdvfile: / / URL pour les chemins de fileystem
+
+Plugins qui ont besoin d'écrire dans le système de fichiers pouvez convertir un fichier reçu système URL vers un emplacement de système de fichiers réels. Il y a plusieurs façons de le faire, selon la plate-forme native.
+
+Il est important de rappeler que pas tous les `cdvfile://` URL sont cartographiables à des fichiers sur le périphérique. Certaines URL peut faire référence aux actifs sur les périphériques qui ne sont pas représentés par des fichiers, ou peuvent même faire référence aux ressources distantes. En raison de ces possibilités, plugins devraient toujours tester si ils obtiennent un résultat significatif, retour en essayant de convertir les URL aux chemins d'accès.
+
+#### Android
+
+Sur Android, la méthode la plus simple pour convertir un `cdvfile://` URL vers un chemin d'accès de système de fichiers est d'utiliser `org.apache.cordova.CordovaResourceApi` . `CordovaResourceApi`comporte plusieurs méthodes qui peuvent gérer `cdvfile://` URL :
+
+ // webView is a member of the Plugin class
+ CordovaResourceApi resourceApi = webView.getResourceApi();
+
+ // Obtain a file:/// URL representing this file on the device,
+ // or the same URL unchanged if it cannot be mapped to a file
+ Uri fileURL = resourceApi.remapUri(Uri.parse(cdvfileURL));
+
+
+Il est également possible d'utiliser le fichier plugin directement :
+
+ import org.apache.cordova.file.FileUtils;
+ import org.apache.cordova.file.FileSystem;
+ import java.net.MalformedURLException;
+
+ // Get the File plugin from the plugin manager
+ FileUtils filePlugin = (FileUtils)webView.pluginManager.getPlugin("File");
+
+ // Given a URL, get a path for it
+ try {
+ String path = filePlugin.filesystemPathForURL(cdvfileURL);
+ } catch (MalformedURLException e) {
+ // The filesystem url wasn't recognized
+ }
+
+
+Pour convertir un chemin d'accès à un `cdvfile://` URL :
+
+ import org.apache.cordova.file.LocalFilesystemURL;
+
+ // Get a LocalFilesystemURL object for a device path,
+ // or null if it cannot be represented as a cdvfile URL.
+ LocalFilesystemURL url = filePlugin.filesystemURLforLocalPath(path);
+ // Get the string representation of the URL object
+ String cdvfileURL = url.toString();
+
+
+Si votre plugin crée un fichier et que vous souhaitez renvoyer un objet FileEntry pour cela, utilisez le fichier plugin :
+
+ // Return a JSON structure suitable for returning to JavaScript,
+ // or null if this file is not representable as a cdvfile URL.
+ JSONObject entry = filePlugin.getEntryForFile(file);
+
+
+#### iOS
+
+Cordova sur iOS n'utilise pas le même `CordovaResourceApi` concept d'Android. Sur iOS, vous devez utiliser le fichier plugin pour convertir entre les URL et les chemins d'accès de système de fichiers.
+
+ // Get a CDVFilesystem URL object from a URL string
+ CDVFilesystemURL* url = [CDVFilesystemURL fileSystemURLWithString:cdvfileURL];
+ // Get a path for the URL object, or nil if it cannot be mapped to a file
+ NSString* path = [filePlugin filesystemPathForURL:url];
+
+
+ // Get a CDVFilesystem URL object for a device path, or
+ // nil if it cannot be represented as a cdvfile URL.
+ CDVFilesystemURL* url = [filePlugin fileSystemURLforLocalPath:path];
+ // Get the string representation of the URL object
+ NSString* cdvfileURL = [url absoluteString];
+
+
+Si votre plugin crée un fichier et que vous souhaitez renvoyer un objet FileEntry pour cela, utilisez le fichier plugin :
+
+ // Get a CDVFilesystem URL object for a device path, or
+ // nil if it cannot be represented as a cdvfile URL.
+ CDVFilesystemURL* url = [filePlugin fileSystemURLforLocalPath:path];
+ // Get a structure to return to JavaScript
+ NSDictionary* entry = [filePlugin makeEntryForLocalURL:url]
+
+
+#### JavaScript
+
+En JavaScript, pour obtenir un `cdvfile://` URL d'un objet FileEntry ou DirectoryEntry, il suffit d'appeler `.toURL()` à ce sujet :
+
+ var cdvfileURL = entry.toURL();
+
+
+Dans gestionnaires de plugin de réponse, pour convertir une structure FileEntry retournée vers un objet réel de l'entrée, votre code de gestionnaire doit importer le fichier plugin et créer un nouvel objet :
+
+ // create appropriate Entry object
+ var entry;
+ if (entryStruct.isDirectory) {
+ entry = new DirectoryEntry(entryStruct.name, entryStruct.fullPath, new FileSystem(entryStruct.filesystemName));
+ } else {
+ entry = new FileEntry(entryStruct.name, entryStruct.fullPath, new FileSystem(entryStruct.filesystemName));
+ }
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-plugin-file/blob/05e393dd/doc/it/index.md
----------------------------------------------------------------------
diff --git a/doc/it/index.md b/doc/it/index.md
new file mode 100644
index 0000000..dcff555
--- /dev/null
+++ b/doc/it/index.md
@@ -0,0 +1,201 @@
+<!---
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+
+# org.apache.cordova.file
+
+Questo plugin fornisce le [API di HTML5 Filesystem][1]. Per l'utilizzo, fare riferimento all' [FileSystem articolo][2] sull'argomento HTML5 Rocks'. Per una panoramica delle altre opzioni di archiviazione, consultare [Guida di archiviazione di Cordova][3].
+
+ [1]: http://dev.w3.org/2009/dap/file-system/pub/FileSystem/
+ [2]: http://www.html5rocks.com/en/tutorials/file/filesystem/
+ [3]: http://cordova.apache.org/docs/en/edge/cordova_storage_storage.md.html
+
+## Installazione
+
+ cordova plugin add org.apache.cordova.file
+
+
+## Piattaforme supportate
+
+* Amazon fuoco OS
+* Android
+* BlackBerry 10
+* iOS
+* Windows Phone 7 e 8 *
+* Windows 8 *
+* Firefox OS
+
+* *Non supportano queste piattaforme `FileReader.readAsArrayBuffer` né `FileWriter.write(blob)` .*
+
+## Dove memorizzare i file
+
+A partire dalla v 1.2.0, vengono forniti gli URL per le directory importanti file di sistema. Ogni URL è nella forma *file:///path/to/spot/*e può essere convertito in un `DirectoryEntry` utilizzando`window.resolveLocalFileSystemURL()`.
+
+`cordova.file.applicationDirectory`-Sola lettura directory dove è installato l'applicazione. (*iOS*, *Android*)
+
+`cordova.file.applicationStorageDirectory`-Radice di ammasso scrivibile privato dell'app. (*iOS*, *Android*)
+
+`cordova.file.dataDirectory`-Dove mettere i file di dati specifici di app. (*iOS*, *Android*)
+
+`cordova.file.cacheDirectory`-I file che dovrebbero sopravvivere si riavvia app nella cache. Apps non devono basarsi sull'OS di eliminare i file qui. (*iOS*, *Android*)
+
+`cordova.file.externalApplicationStorageDirectory`-Spazio applicazione su storage esterno. (*iOS*, *Android*)
+
+`cordova.file.externalDataDirectory`-Dove mettere i file di dati specifico app su storage esterno. (*Android*)
+
+`cordova.file.externalCacheDirectory`-Cache applicazione su storage esterno. (*Android*)
+
+`cordova.file.externalRootDirectory`-Radice di archiviazione esterna (scheda SD). (*Android*)
+
+`cordova.file.tempDirectory`-Temp directory che l'OS è possibile cancellare a volontà. (*iOS*)
+
+`cordova.file.syncedDataDirectory`-Contiene i file app specifiche che devono essere sincronizzati (per esempio a iCloud). (*iOS*)
+
+`cordova.file.documentsDirectory`-I file privati per le app, ma che sono significativi per altri nonché (ad es. file di Office). (*iOS*)
+
+## Stranezze Android
+
+### Posizione di archiviazione persistente Android
+
+Ci sono più percorsi validi per memorizzare i file persistenti su un dispositivo Android. Vedi [questa pagina][4] per un'ampia discussione delle varie possibilità.
+
+ [4]: http://developer.android.com/guide/topics/data/data-storage.html
+
+Versioni precedenti del plugin avrebbe scelto il percorso dei file temporanei e permanenti su avvio, in base se il dispositivo ha sostenuto che la scheda SD (o partizione storage equivalente) è stato montato. Se è stata montata sulla scheda SD o una partizione di storage interno grande era disponibile (come sui dispositivi Nexus,) allora saranno memorizzati i file persistenti nella radice di quello spazio. Questo significava che tutte le apps di Cordova poteva vedere tutti i file disponibili sulla carta.
+
+Se la scheda SD non era disponibile, versioni precedenti vuoi memorizzare dati sotto /dati/dati /<packageid>, che isola i apps da altro, ma possono ancora causare dati da condividere tra gli utenti.
+
+Ora è possibile scegliere se memorizzare i file nel percorso di archiviazione di file interno o utilizzando la logica precedente, con una preferenza nel file config. XML dell'applicazione. Per fare questo, aggiungere una di queste due linee al file config. xml:
+
+ <preference name="AndroidPersistentFileLocation" value="Internal" />
+
+ <preference name="AndroidPersistentFileLocation" value="Compatibility" />
+
+
+Senza questa linea, il File del plugin utilizzerà "Compatibilità" come predefinito. Se è presente un tag di preferenza e non è uno di questi valori, l'applicazione non si avvia.
+
+Se l'applicazione è stato spedito in precedenza agli utenti, utilizzando un vecchio (pre-1.0) versione di questo plugin e ha i file memorizzati nel filesystem persistente, allora si dovrebbe impostare la preferenza alla "Compatibilità". La posizione su "Interno" di commutazione significherebbe che gli utenti esistenti che aggiornare la loro applicazione potrebbero essere Impossibile accedere ai loro file precedentemente memorizzati, a seconda del loro dispositivo.
+
+Se l'applicazione è nuova, o ha mai precedentemente memorizzati i file nel filesystem persistente, è generalmente consigliato l'impostazione "interno".
+
+## iOS stranezze
+
+* `FileReader.readAsText(blob, encoding)`
+ * Il `encoding` parametro non è supportato, e codifica UTF-8 è sempre attivo.
+
+### posizione di archiviazione persistente di iOS
+
+Ci sono due percorsi validi per memorizzare i file persistenti su un dispositivo iOS: la directory documenti e la biblioteca. Precedenti versioni del plugin archiviati solo mai persistenti file nella directory documenti. Questo ha avuto l'effetto collaterale di tutti i file di un'applicazione che rende visibili in iTunes, che era spesso involontaria, soprattutto per le applicazioni che gestiscono un sacco di piccoli file, piuttosto che produrre documenti completi per l'esportazione, che è la destinazione della directory.
+
+Ora è possibile scegliere se memorizzare i file nella directory di libreria, con una preferenza nel file config. XML dell'applicazione o documenti. Per fare questo, aggiungere una di queste due linee al file config. xml:
+
+ <preference name="iosPersistentFileLocation" value="Library" />
+
+ <preference name="iosPersistentFileLocation" value="Compatibility" />
+
+
+Senza questa linea, il File del plugin utilizzerà "Compatibilità" come predefinito. Se è presente un tag di preferenza e non è uno di questi valori, l'applicazione non si avvia.
+
+Se l'applicazione è stato spedito in precedenza agli utenti, utilizzando un vecchio (pre-1.0) versione di questo plugin e ha i file memorizzati nel filesystem persistente, allora si dovrebbe impostare la preferenza alla "Compatibilità". La posizione di "Libreria" di commutazione significherebbe che gli utenti esistenti che aggiornare la loro applicazione è in grado di accedere ai loro file precedentemente memorizzati.
+
+Se l'applicazione è nuova, o ha mai precedentemente memorizzati i file nel filesystem persistente, è generalmente consigliato l'impostazione "Libreria".
+
+### Firefox OS stranezze
+
+L'API di sistema del File non è supportato nativamente dal sistema operativo Firefox e viene implementato come uno spessore in cima indexedDB.
+
+* Non manca quando si rimuove le directory non vuota
+* Non supporta i metadati per le directory
+* Non supporta `requestAllFileSystems` e `resolveLocalFileSystemURI` metodi
+* Metodi `copyTo` e `moveTo` non supporta le directory
+
+## Note di aggiornamento
+
+In v 1.0.0 di questo plugin, il `FileEntry` e `DirectoryEntry` strutture sono cambiati, per essere più in linea con le specifiche pubblicate.
+
+Versioni precedenti (pre-1.0.0) del plugin archiviati il dispositivo-assoluto--percorso del file nella `fullPath` proprietà di `Entry` oggetti. In genere questi percorsi si sarebbe simile
+
+ /var/mobile/Applications/<application UUID>/Documents/path/to/file (iOS)
+ /storage/emulated/0/path/to/file (Android)
+
+
+Questi percorsi sono stati restituiti anche dal `toURL()` metodo della `Entry` oggetti.
+
+Con v 1.0.0, la `fullPath` attributo è il percorso del file, *rispetto alla radice del filesystem HTML*. Così, i percorsi sopra sarebbe ora sia rappresentato da un `FileEntry` oggetto con un `fullPath` di
+
+ /path/to/file
+
+
+Se l'applicazione funziona con dispositivo-assoluto-percorsi, e estratto in precedenza tali percorsi attraverso la `fullPath` proprietà di `Entry` oggetti, allora si dovrebbe aggiornare il codice per utilizzare `entry.toURL()` invece.
+
+Per indietro compatibilità, il `resolveLocalFileSystemURL()` Metodo accetterà un dispositivo-assoluto-percorso e restituirà un `Entry` oggetto corrispondente ad essa, fintanto che il file esiste all'interno del filesystem temporaneo o permanente.
+
+Questo particolare è stato un problema con il plugin di trasferimento File, che in precedenza utilizzati percorsi-dispositivo-assoluto (e ancora può accoglierli). Esso è stato aggiornato per funzionare correttamente con gli URL di FileSystem, così sostituendo `entry.fullPath` con `entry.toURL()` dovrebbe risolvere eventuali problemi ottenendo quel plugin per lavorare con i file nel dispositivo.
+
+In v. 1.1.0 il valore restituito di `toURL()` è stato cambiato (vedere \[CB-6394\] (https://issues.apache.org/jira/browse/CB-6394)) per restituire un URL assoluto 'file://'. ove possibile. Per assicurare un ' cdvfile:'-URL, è possibile utilizzare `toInternalURL()` ora. Questo metodo restituirà ora filesystem URL del modulo
+
+ cdvfile://localhost/persistent/path/to/file
+
+
+che può essere utilizzato per identificare univocamente il file.
+
+## Elenco dei codici di errore e significati
+
+Quando viene generato un errore, uno dei seguenti codici da utilizzare.
+
+* 1 = NOT\_FOUND\_ERR
+* 2 = SECURITY_ERR
+* 3 = ABORT_ERR
+* 4 = NOT\_READABLE\_ERR
+* 5 = ENCODING_ERR
+* 6 = NO\_MODIFICATION\_ALLOWED_ERR
+* 7 = INVALID\_STATE\_ERR
+* 8 = SYNTAX_ERR
+* 9 = INVALID\_MODIFICATION\_ERR
+* 10 = QUOTA\_EXCEEDED\_ERR
+* 11 = TYPE\_MISMATCH\_ERR
+* 12 = PATH\_EXISTS\_ERR
+
+## Configurare il Plugin (opzionale)
+
+Il set di filesystem disponibili può essere configurato per ogni piattaforma. Sia iOS che Android riconoscere un <preference> taggare in `config.xml` che denomina il filesystem per essere installato. Per impostazione predefinita, tutte le radici del file system sono abilitate.
+
+ <preference name="iosExtraFilesystems" value="library,library-nosync,documents,documents-nosync,cache,bundle,root" />
+ <preference name="AndroidExtraFilesystems" value="files,files-external,documents,sdcard,cache,cache-external,root" />
+
+
+### Android
+
+* File: directory di archiviazione di file interno dell'applicazione
+* file-esterno: directory di archiviazione dell'applicazione file esterno
+* sdcard: la directory di archiviazione di file esterni globale (questa è la radice della scheda SD, se uno è installato). Deve avere il `android.permission.WRITE_EXTERNAL_STORAGE` il permesso di usare questo.
+* cache: la cache interna directory applicazione
+* cache-esterno: directory di cache esterna dell'applicazione
+* radice: il dispositivo intero filesystem
+
+Android supporta anche un filesystem speciale denominato "documenti", che rappresenta una sottodirectory "/ documenti /" all'interno del filesystem "files".
+
+### iOS
+
+* Biblioteca: la directory dell'applicazione libreria
+* documenti: la directory dell'applicazione documenti
+* cache: la Cache directory applicazione
+* bundle: bundle dell'applicazione; la posizione dell'app sul disco (sola lettura)
+* radice: il dispositivo intero filesystem
+
+Per impostazione predefinita, la directory di libreria e documenti può essere sincronizzata a iCloud. È anche possibile richiedere due filesystem aggiuntivi, "biblioteca-nosync" e "documenti-nosync", che rappresentano una speciale directory non sincronizzati entro il filesystem libreria o documenti.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-plugin-file/blob/05e393dd/doc/it/plugins.md
----------------------------------------------------------------------
diff --git a/doc/it/plugins.md b/doc/it/plugins.md
new file mode 100644
index 0000000..c02ca2f
--- /dev/null
+++ b/doc/it/plugins.md
@@ -0,0 +1,124 @@
+<!---
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+
+# Note per gli sviluppatori di plugin
+
+Queste note sono principalmente destinate agli sviluppatori di Android e iOS che vogliono scrivere plugin quale interfaccia con il sistema di file utilizzando il File del plugin.
+
+## Lavorare con file di Cordova sistema gli URL
+
+Dalla versione 1.0.0, questo plugin ha utilizzato gli URL con un `cdvfile` regime per tutte le comunicazioni oltre il ponte, piuttosto che esporre i percorsi del dispositivo raw file system a JavaScript.
+
+Sul lato JavaScript, questo significa che gli oggetti FileEntry e DirectoryEntry hanno un attributo fullPath che è relativo alla directory principale del sistema di file HTML. Se JavaScript API del vostro plugin accetta un oggetto FileEntry o DirectoryEntry, dovrebbe chiamare `.toURL()` su quell'oggetto prima di passarlo attraverso il ponte in codice nativo.
+
+### Conversione cdvfile: / / URL per percorsi fileystem
+
+Plugin che occorre scrivere al filesystem potrebbe voler convertire un URL del sistema file ricevuto in una filesystem effettiva posizione. Ci sono diversi modi di fare questo, a seconda della piattaforma nativa.
+
+È importante ricordare che non tutti i `cdvfile://` gli URL sono mappabili ai veri file sul dispositivo. Alcuni URL può riferirsi a beni sul dispositivo che non sono rappresentati da file, o possono anche riferirsi a risorse remote. A causa di queste possibilità, plugin dovrebbe sempre verificare se ottengono un risultato espressivo indietro quando si tenta di convertire gli URL in tracciati.
+
+#### Android
+
+Su Android, il metodo più semplice per convertire un `cdvfile://` URL a un percorso di file System è quello di utilizzare `org.apache.cordova.CordovaResourceApi` . `CordovaResourceApi`dispone di diversi metodi in grado di gestire `cdvfile://` URL:
+
+ // webView is a member of the Plugin class
+ CordovaResourceApi resourceApi = webView.getResourceApi();
+
+ // Obtain a file:/// URL representing this file on the device,
+ // or the same URL unchanged if it cannot be mapped to a file
+ Uri fileURL = resourceApi.remapUri(Uri.parse(cdvfileURL));
+
+
+È anche possibile utilizzare direttamente il File del plugin:
+
+ import org.apache.cordova.file.FileUtils;
+ import org.apache.cordova.file.FileSystem;
+ import java.net.MalformedURLException;
+
+ // Get the File plugin from the plugin manager
+ FileUtils filePlugin = (FileUtils)webView.pluginManager.getPlugin("File");
+
+ // Given a URL, get a path for it
+ try {
+ String path = filePlugin.filesystemPathForURL(cdvfileURL);
+ } catch (MalformedURLException e) {
+ // The filesystem url wasn't recognized
+ }
+
+
+Per convertire da un percorso a un `cdvfile://` URL:
+
+ import org.apache.cordova.file.LocalFilesystemURL;
+
+ // Get a LocalFilesystemURL object for a device path,
+ // or null if it cannot be represented as a cdvfile URL.
+ LocalFilesystemURL url = filePlugin.filesystemURLforLocalPath(path);
+ // Get the string representation of the URL object
+ String cdvfileURL = url.toString();
+
+
+Se il tuo plugin crea un file e si desidera restituire un oggetto FileEntry per esso, utilizzare il File del plugin:
+
+ // Return a JSON structure suitable for returning to JavaScript,
+ // or null if this file is not representable as a cdvfile URL.
+ JSONObject entry = filePlugin.getEntryForFile(file);
+
+
+#### iOS
+
+Cordova su iOS non utilizza lo stesso `CordovaResourceApi` concetto come Android. Su iOS, è necessario utilizzare il File del plugin per la conversione tra URL e percorsi del file System.
+
+ // Get a CDVFilesystem URL object from a URL string
+ CDVFilesystemURL* url = [CDVFilesystemURL fileSystemURLWithString:cdvfileURL];
+ // Get a path for the URL object, or nil if it cannot be mapped to a file
+ NSString* path = [filePlugin filesystemPathForURL:url];
+
+
+ // Get a CDVFilesystem URL object for a device path, or
+ // nil if it cannot be represented as a cdvfile URL.
+ CDVFilesystemURL* url = [filePlugin fileSystemURLforLocalPath:path];
+ // Get the string representation of the URL object
+ NSString* cdvfileURL = [url absoluteString];
+
+
+Se il tuo plugin crea un file e si desidera restituire un oggetto FileEntry per esso, utilizzare il File del plugin:
+
+ // Get a CDVFilesystem URL object for a device path, or
+ // nil if it cannot be represented as a cdvfile URL.
+ CDVFilesystemURL* url = [filePlugin fileSystemURLforLocalPath:path];
+ // Get a structure to return to JavaScript
+ NSDictionary* entry = [filePlugin makeEntryForLocalURL:url]
+
+
+#### JavaScript
+
+In JavaScript, per ottenere un `cdvfile://` URL da un oggetto FileEntry o DirectoryEntry, semplicemente chiamare `.toURL()` su di esso:
+
+ var cdvfileURL = entry.toURL();
+
+
+Nei gestori di risposta plugin, per convertire da una struttura FileEntry restituita in un oggetto effettivo della voce, il codice del gestore dovrebbe importare il File del plugin e creare un nuovo oggetto:
+
+ // create appropriate Entry object
+ var entry;
+ if (entryStruct.isDirectory) {
+ entry = new DirectoryEntry(entryStruct.name, entryStruct.fullPath, new FileSystem(entryStruct.filesystemName));
+ } else {
+ entry = new FileEntry(entryStruct.name, entryStruct.fullPath, new FileSystem(entryStruct.filesystemName));
+ }
\ No newline at end of file