programForGivenTime = new ArrayList<>();
+ if (!channel.repeatPrograms) {
+ for (XmlTvParser.XmlTvProgram program : channelPrograms) {
+ if (program.startTimeUtcMillis <= endTimeMs
+ && program.endTimeUtcMillis >= startTimeMs) {
+ programForGivenTime.add(new Program.Builder()
+ .setChannelId(ContentUris.parseId(channelUri))
+ .setTitle(program.title)
+ .setDescription(program.description)
+ .setContentRatings(XmlTvParser.xmlTvRatingToTvContentRating(
+ program.rating))
+ .setCanonicalGenres(program.category)
+ .setPosterArtUri(program.icon != null ? program.icon.src : null)
+ .setInternalProviderData(TvContractUtil.
+ convertVideoInfoToInternalProviderData(
+ program.videoType,
+ program.videoSrc != null ? program.videoSrc : channel.url))
+ .setStartTimeUtcMillis(program.startTimeUtcMillis)
+ .setEndTimeUtcMillis(program.endTimeUtcMillis)
+ .build()
+ );
+ }
+ }
+ return programForGivenTime;
+ }
+
+ // If repeat-programs is on, schedule the programs sequentially in a loop. To make every
+ // device play the same program in a given channel and time, we assumes the loop started
+ // from the epoch time.
+ long totalDurationMs = 0;
+ for (XmlTvParser.XmlTvProgram program : channelPrograms) {
+ totalDurationMs += program.getDurationMillis();
+ }
+
+ long programStartTimeMs = startTimeMs - startTimeMs % totalDurationMs;
+ int i = 0;
+ final int programCount = channelPrograms.size();
+ while (programStartTimeMs < endTimeMs) {
+ XmlTvParser.XmlTvProgram programInfo = channelPrograms.get(i++ % programCount);
+ long programEndTimeMs = programStartTimeMs + programInfo.getDurationMillis();
+ if (programEndTimeMs < startTimeMs) {
+ programStartTimeMs = programEndTimeMs;
+ continue;
+ }
+ programForGivenTime.add(new Program.Builder()
+ .setChannelId(ContentUris.parseId(channelUri))
+ .setTitle(programInfo.title)
+ .setDescription(programInfo.description)
+ .setContentRatings(XmlTvParser.xmlTvRatingToTvContentRating(
+ programInfo.rating))
+ .setCanonicalGenres(programInfo.category)
+ .setPosterArtUri(programInfo.icon.src)
+ // NOTE: {@code COLUMN_INTERNAL_PROVIDER_DATA} is a private field where
+ // TvInputService can store anything it wants. Here, we store video type and
+ // video URL so that TvInputService can play the video later with this field.
+ .setInternalProviderData(TvContractUtil.convertVideoInfoToInternalProviderData(
+ programInfo.videoType,
+ programInfo.videoSrc != null ? programInfo.videoSrc : channel.url))
+ .setStartTimeUtcMillis(programStartTimeMs)
+ .setEndTimeUtcMillis(programEndTimeMs)
+ .build()
+ );
+ programStartTimeMs = programEndTimeMs;
+ }
+ return programForGivenTime;
+ }
+
+ /**
+ * Updates the system database, TvProvider, with the given programs.
+ *
+ * If there is any overlap between the given and existing programs, the existing ones
+ * will be updated with the given ones if they have the same title or replaced.
+ *
+ * @param channelUri The channel where the program info will be added.
+ * @param newPrograms A list of {@link Program} instances which includes program
+ * information.
+ */
+ private void updatePrograms(Uri channelUri, List newPrograms) {
+ final int fetchedProgramsCount = newPrograms.size();
+ if (fetchedProgramsCount == 0) {
+ return;
+ }
+ List oldPrograms = TvContractUtil.getPrograms(context.getContentResolver(),
+ channelUri);
+ Program firstNewProgram = newPrograms.get(0);
+ int oldProgramsIndex = 0;
+ int newProgramsIndex = 0;
+ // Skip the past programs. They will be automatically removed by the system.
+ for (Program program : oldPrograms) {
+ oldProgramsIndex++;
+ if(program.getEndTimeUtcMillis() > firstNewProgram.getStartTimeUtcMillis()) {
+ break;
+ }
+ }
+ // Compare the new programs with old programs one by one and update/delete the old one or
+ // insert new program if there is no matching program in the database.
+ ArrayList ops = new ArrayList<>();
+ while (newProgramsIndex < fetchedProgramsCount) {
+ Program oldProgram = oldProgramsIndex < oldPrograms.size()
+ ? oldPrograms.get(oldProgramsIndex) : null;
+ Program newProgram = newPrograms.get(newProgramsIndex);
+ boolean addNewProgram = false;
+ if (oldProgram != null) {
+ if (oldProgram.equals(newProgram)) {
+ // Exact match. No need to update. Move on to the next programs.
+ oldProgramsIndex++;
+ newProgramsIndex++;
+ } else if (needsUpdate(oldProgram, newProgram)) {
+ // Partial match. Update the old program with the new one.
+ // NOTE: Use 'update' in this case instead of 'insert' and 'delete'. There could
+ // be application specific settings which belong to the old program.
+ ops.add(ContentProviderOperation.newUpdate(
+ TvContract.buildProgramUri(oldProgram.getProgramId()))
+ .withValues(newProgram.toContentValues())
+ .build());
+ oldProgramsIndex++;
+ newProgramsIndex++;
+ } else if (oldProgram.getEndTimeUtcMillis() < newProgram.getEndTimeUtcMillis()) {
+ // No match. Remove the old program first to see if the next program in
+ // {@code oldPrograms} partially matches the new program.
+ ops.add(ContentProviderOperation.newDelete(
+ TvContract.buildProgramUri(oldProgram.getProgramId()))
+ .build());
+ oldProgramsIndex++;
+ } else {
+ // No match. The new program does not match any of the old programs. Insert it
+ // as a new program.
+ addNewProgram = true;
+ newProgramsIndex++;
+ }
+ } else {
+ // No old programs. Just insert new programs.
+ addNewProgram = true;
+ newProgramsIndex++;
+ }
+ if (addNewProgram) {
+ ops.add(ContentProviderOperation
+ .newInsert(TvContract.Programs.CONTENT_URI)
+ .withValues(newProgram.toContentValues())
+ .build());
+ }
+ // Throttle the batch operation not to cause TransactionTooLargeException.
+ if (ops.size() > BATCH_OPERATION_COUNT
+ || newProgramsIndex >= fetchedProgramsCount) {
+ try {
+ context.getContentResolver().applyBatch(TvContract.AUTHORITY, ops);
+ } catch (RemoteException | OperationApplicationException e) {
+ Log.e(TAG, "Failed to insert programs.", e);
+ return;
+ }
+ ops.clear();
+ }
+ }
+ }
+
+ /**
+ * Returns {@code true} if the {@code oldProgram} program needs to be updated with the
+ * {@code newProgram} program.
+ */
+ private boolean needsUpdate(Program oldProgram, Program newProgram) {
+ // NOTE: Here, we update the old program if it has the same title and overlaps with the new
+ // program. The test logic is just an example and you can modify this. E.g. check whether
+ // the both programs have the same program ID if your EPG supports any ID for the programs.
+ return oldProgram.getTitle().equals(newProgram.getTitle())
+ && oldProgram.getStartTimeUtcMillis() <= newProgram.getEndTimeUtcMillis()
+ && newProgram.getStartTimeUtcMillis() <= oldProgram.getEndTimeUtcMillis();
+ }
+}
diff --git a/app/src/main/java/at/pansy/iptv/util/IptvUtil.java b/app/src/main/java/at/pansy/iptv/util/IptvUtil.java
new file mode 100644
index 0000000..ddacc12
--- /dev/null
+++ b/app/src/main/java/at/pansy/iptv/util/IptvUtil.java
@@ -0,0 +1,140 @@
+package at.pansy.iptv.util;
+
+import android.content.ContentResolver;
+import android.content.Context;
+import android.net.Uri;
+import android.util.Log;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.BufferedInputStream;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.zip.GZIPInputStream;
+
+import at.pansy.iptv.xmltv.XmlTvParser;
+
+/**
+ * Static helper methods for fetching the channel feed.
+ */
+public class IptvUtil {
+
+ public static final int FORMAT_XMLTV = 0;
+ public static final int FORMAT_M3U = 1;
+
+ private static final String TAG = "IptvUtil";
+ private static HashMap sampleTvListings = new HashMap<>();
+
+ private static final int URLCONNECTION_CONNECTION_TIMEOUT_MS = 3000; // 3 sec
+ private static final int URLCONNECTION_READ_TIMEOUT_MS = 10000; // 10 sec
+
+ private IptvUtil() {
+ }
+
+ public static XmlTvParser.TvListing getTvListings(Context context, String url, int format) {
+
+ if (sampleTvListings.containsKey(url)) {
+ return sampleTvListings.get(url);
+ }
+
+ Uri catalogUri =
+ Uri.parse(url).normalizeScheme();
+
+ XmlTvParser.TvListing sampleTvListing = null;
+ try {
+ InputStream inputStream = getInputStream(context, catalogUri);
+ if (url.endsWith(".gz")) {
+ inputStream = new GZIPInputStream(inputStream);
+ }
+ if (format == FORMAT_M3U) {
+ sampleTvListing = parse(inputStream);
+ } else {
+ sampleTvListing = XmlTvParser.parse(inputStream);
+ }
+ } catch (IOException e) {
+ Log.e(TAG, "Error in fetching " + catalogUri, e);
+ }
+ if (sampleTvListing != null) {
+ sampleTvListings.put(url, sampleTvListing);
+ }
+ return sampleTvListing;
+ }
+
+ public static InputStream getInputStream(Context context, Uri uri) throws IOException {
+ InputStream inputStream;
+ if (ContentResolver.SCHEME_ANDROID_RESOURCE.equals(uri.getScheme())
+ || ContentResolver.SCHEME_ANDROID_RESOURCE.equals(uri.getScheme())
+ || ContentResolver.SCHEME_FILE.equals(uri.getScheme())) {
+ inputStream = context.getContentResolver().openInputStream(uri);
+ } else {
+ URLConnection urlConnection = new URL(uri.toString()).openConnection();
+ urlConnection.setConnectTimeout(URLCONNECTION_CONNECTION_TIMEOUT_MS);
+ urlConnection.setReadTimeout(URLCONNECTION_READ_TIMEOUT_MS);
+ inputStream = urlConnection.getInputStream();
+ }
+ return new BufferedInputStream(inputStream);
+ }
+
+ private static XmlTvParser.TvListing parse(InputStream inputStream) throws IOException {
+ BufferedReader in = new BufferedReader(new InputStreamReader(inputStream));
+ String line;
+ List channels = new ArrayList<>();
+ List programs = new ArrayList<>();
+ Map channelMap = new HashMap<>();
+
+ while ((line = in.readLine()) != null) {
+ if (line.startsWith("#EXTINF:")) {
+ // #EXTINF:0051 tvg-id="blizz.de" group-title="DE Spartensender" tvg-logo="897815.png", [COLOR orangered]blizz TV HD[/COLOR]
+
+ String id = null;
+ String displayName = null;
+ String displayNumber = null;
+ int originalNetworkId = 0;
+ XmlTvParser.XmlTvIcon icon = null;
+
+ String[] parts = line.split(", ", 2);
+ if (parts.length == 2) {
+ for (String part : parts[0].split(" ")) {
+ if (part.startsWith("#EXTINF:")) {
+ displayNumber = part.substring(8).replaceAll("^0+", "");
+ originalNetworkId = Integer.parseInt(displayNumber);
+ } else if (part.startsWith("tvg-id=")) {
+ int end = part.indexOf("\"", 8);
+ if (end > 8) {
+ id = part.substring(8, end);
+ }
+ } else if (part.startsWith("tvg-logo=")) {
+ int end = part.indexOf("\"", 10);
+ if (end > 10) {
+ icon = new XmlTvParser.XmlTvIcon("http://logo.iptv.ink/"
+ + part.substring(10, end));
+ }
+ }
+ }
+ displayName = parts[1].replaceAll("\\[\\/?COLOR[^\\]]*\\]", "");
+ }
+
+ if (originalNetworkId != 0 && displayName != null) {
+ XmlTvParser.XmlTvChannel channel =
+ new XmlTvParser.XmlTvChannel(id, displayName, displayNumber, icon,
+ originalNetworkId, 0, 0, false);
+ if (channelMap.containsKey(originalNetworkId)) {
+ channels.set(channelMap.get(originalNetworkId), channel);
+ } else {
+ channelMap.put(originalNetworkId, channels.size());
+ channels.add(channel);
+ }
+ }
+ } else if (line.startsWith("http") && channels.size() > 0) {
+ channels.get(channels.size()-1).url = line;
+ }
+ }
+ return new XmlTvParser.TvListing(channels, programs);
+ }
+}
diff --git a/app/src/main/java/at/pansy/iptv/util/RendererUtil.java b/app/src/main/java/at/pansy/iptv/util/RendererUtil.java
new file mode 100644
index 0000000..a647126
--- /dev/null
+++ b/app/src/main/java/at/pansy/iptv/util/RendererUtil.java
@@ -0,0 +1,41 @@
+package at.pansy.iptv.util;
+
+import android.content.Context;
+;
+import com.google.android.exoplayer.upstream.DefaultHttpDataSource;
+import com.google.android.exoplayer.upstream.DefaultUriDataSource;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Created by notz.
+ */
+public class RendererUtil {
+
+ public static String processUrlParameters(String url, HashMap httpHeaders) {
+ String[] parameters = url.split("\\|");
+ for (int i = 1; i < parameters.length; i++) {
+ String[] pair = parameters[i].split("=", 2);
+ if (pair.length == 2) {
+ httpHeaders.put(pair[0], pair[1]);
+ }
+ }
+
+ return parameters[0];
+ }
+
+ public static DefaultUriDataSource createDefaultUriDataSource(Context context, String userAgent,
+ HashMap httpHeaders) {
+
+ DefaultHttpDataSource httpDataSource = new DefaultHttpDataSource(userAgent, null, null,
+ DefaultHttpDataSource.DEFAULT_CONNECT_TIMEOUT_MILLIS,
+ DefaultHttpDataSource.DEFAULT_READ_TIMEOUT_MILLIS, false);
+
+ for (Map.Entry header : httpHeaders.entrySet()) {
+ httpDataSource.setRequestProperty(header.getKey(), header.getValue());
+ }
+
+ return new DefaultUriDataSource(context, null, httpDataSource);
+ }
+}
diff --git a/app/src/main/java/at/pansy/iptv/util/SyncUtil.java b/app/src/main/java/at/pansy/iptv/util/SyncUtil.java
new file mode 100644
index 0000000..54eaa58
--- /dev/null
+++ b/app/src/main/java/at/pansy/iptv/util/SyncUtil.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2015 The Android Open Source Project
+ *
+ * Licensed 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.
+ */
+
+package at.pansy.iptv.util;
+
+import android.accounts.Account;
+import android.accounts.AccountManager;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.media.tv.TvContract;
+import android.os.Bundle;
+import android.util.Log;
+
+import at.pansy.iptv.service.AccountService;
+import at.pansy.iptv.sync.SyncAdapter;
+
+/**
+ * Static helper methods for working with the SyncAdapter framework.
+ */
+public class SyncUtil {
+
+ public static final String ACCOUNT_TYPE = "at.pansy.iptv.account";
+
+ private static final String TAG = "SyncUtil";
+ private static final String CONTENT_AUTHORITY = TvContract.AUTHORITY;
+
+ public static void setUpPeriodicSync(Context context, String inputId) {
+ Account account = AccountService.getAccount(ACCOUNT_TYPE);
+ AccountManager accountManager =
+ (AccountManager) context.getSystemService(Context.ACCOUNT_SERVICE);
+ if (!accountManager.addAccountExplicitly(account, null, null)) {
+ Log.e(TAG, "Account already exists.");
+ }
+ ContentResolver.setIsSyncable(account, CONTENT_AUTHORITY, 1);
+ ContentResolver.setSyncAutomatically(account, CONTENT_AUTHORITY, true);
+ Bundle bundle = new Bundle();
+ bundle.putString(SyncAdapter.BUNDLE_KEY_INPUT_ID, inputId);
+ ContentResolver.addPeriodicSync(account, CONTENT_AUTHORITY, bundle,
+ SyncAdapter.FULL_SYNC_FREQUENCY_SEC);
+ }
+
+ public static void requestSync(String inputId, boolean currentProgramOnly) {
+ Bundle bundle = new Bundle();
+ bundle.putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true);
+ bundle.putBoolean(ContentResolver.SYNC_EXTRAS_EXPEDITED, true);
+ bundle.putString(SyncAdapter.BUNDLE_KEY_INPUT_ID, inputId);
+ bundle.putBoolean(SyncAdapter.BUNDLE_KEY_CURRENT_PROGRAM_ONLY, currentProgramOnly);
+ ContentResolver.requestSync(AccountService.getAccount(ACCOUNT_TYPE), CONTENT_AUTHORITY,
+ bundle);
+ }
+}
diff --git a/app/src/main/java/at/pansy/iptv/util/TvContractUtil.java b/app/src/main/java/at/pansy/iptv/util/TvContractUtil.java
new file mode 100644
index 0000000..18f0fec
--- /dev/null
+++ b/app/src/main/java/at/pansy/iptv/util/TvContractUtil.java
@@ -0,0 +1,349 @@
+/*
+ * Copyright 2015 The Android Open Source Project
+ *
+ * Licensed 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.
+ */
+
+package at.pansy.iptv.util;
+
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.media.tv.TvContentRating;
+import android.media.tv.TvContract;
+import android.media.tv.TvContract.Channels;
+import android.media.tv.TvContract.Programs;
+import android.net.Uri;
+import android.os.AsyncTask;
+import android.text.TextUtils;
+import android.util.Log;
+import android.util.LongSparseArray;
+import android.util.Pair;
+import android.util.SparseArray;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import at.pansy.iptv.domain.Channel;
+import at.pansy.iptv.domain.PlaybackInfo;
+import at.pansy.iptv.domain.Program;
+import at.pansy.iptv.xmltv.XmlTvParser;
+
+/**
+ * Static helper methods for working with {@link TvContract}.
+ */
+public class TvContractUtil {
+ private static final String TAG = "TvContractUtils";
+ private static final boolean DEBUG = true;
+
+ private static final SparseArray VIDEO_HEIGHT_TO_FORMAT_MAP = new SparseArray<>();
+
+ static {
+ VIDEO_HEIGHT_TO_FORMAT_MAP.put(480, Channels.VIDEO_FORMAT_480P);
+ VIDEO_HEIGHT_TO_FORMAT_MAP.put(576, Channels.VIDEO_FORMAT_576P);
+ VIDEO_HEIGHT_TO_FORMAT_MAP.put(720, Channels.VIDEO_FORMAT_720P);
+ VIDEO_HEIGHT_TO_FORMAT_MAP.put(1080, Channels.VIDEO_FORMAT_1080P);
+ VIDEO_HEIGHT_TO_FORMAT_MAP.put(2160, Channels.VIDEO_FORMAT_2160P);
+ VIDEO_HEIGHT_TO_FORMAT_MAP.put(4320, Channels.VIDEO_FORMAT_4320P);
+ }
+
+ private TvContractUtil() {}
+
+ public static void updateChannels(
+ Context context, String inputId, List channels) {
+ // Create a map from original network ID to channel row ID for existing channels.
+ SparseArray mExistingChannelsMap = new SparseArray<>();
+ Uri channelsUri = TvContract.buildChannelsUriForInput(inputId);
+ String[] projection = {Channels._ID, Channels.COLUMN_ORIGINAL_NETWORK_ID};
+ Cursor cursor = null;
+ ContentResolver resolver = context.getContentResolver();
+ try {
+ cursor = resolver.query(channelsUri, projection, null, null, null);
+ while (cursor != null && cursor.moveToNext()) {
+ long rowId = cursor.getLong(0);
+ int originalNetworkId = cursor.getInt(1);
+ mExistingChannelsMap.put(originalNetworkId, rowId);
+ }
+ } finally {
+ if (cursor != null) {
+ cursor.close();
+ }
+ }
+
+ // If a channel exists, update it. If not, insert a new one.
+ ContentValues values = new ContentValues();
+ values.put(Channels.COLUMN_INPUT_ID, inputId);
+ Map logos = new HashMap<>();
+ for (XmlTvParser.XmlTvChannel channel : channels) {
+ values.put(Channels.COLUMN_DISPLAY_NUMBER, channel.displayNumber);
+ values.put(Channels.COLUMN_DISPLAY_NAME, channel.displayName);
+ values.put(Channels.COLUMN_ORIGINAL_NETWORK_ID, channel.originalNetworkId);
+ values.put(Channels.COLUMN_TRANSPORT_STREAM_ID, channel.transportStreamId);
+ values.put(Channels.COLUMN_SERVICE_ID, channel.serviceId);
+ values.put(Channels.COLUMN_INTERNAL_PROVIDER_DATA, channel.url);
+ Long rowId = mExistingChannelsMap.get(channel.originalNetworkId);
+ Uri uri;
+ if (rowId == null) {
+ uri = resolver.insert(Channels.CONTENT_URI, values);
+ } else {
+ uri = TvContract.buildChannelUri(rowId);
+ resolver.update(uri, values, null, null);
+ mExistingChannelsMap.remove(channel.originalNetworkId);
+ }
+ if (!TextUtils.isEmpty(channel.icon.src)) {
+ logos.put(TvContract.buildChannelLogoUri(uri), channel.icon.src);
+ }
+ }
+ if (!logos.isEmpty()) {
+ new InsertLogosTask(context).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, logos);
+ }
+
+ // Deletes channels which don't exist in the new feed.
+ int size = mExistingChannelsMap.size();
+ for (int i = 0; i < size; i++) {
+ Long rowId = mExistingChannelsMap.valueAt(i);
+ resolver.delete(TvContract.buildChannelUri(rowId), null, null);
+ }
+ }
+
+ private static String getVideoFormat(int videoHeight) {
+ return VIDEO_HEIGHT_TO_FORMAT_MAP.get(videoHeight);
+ }
+
+ public static LongSparseArray buildChannelMap(
+ ContentResolver resolver, String inputId, List channels) {
+ Uri uri = TvContract.buildChannelsUriForInput(inputId);
+ String[] projection = {
+ Channels._ID,
+ Channels.COLUMN_DISPLAY_NUMBER
+ };
+
+ LongSparseArray channelMap = new LongSparseArray<>();
+ Cursor cursor = null;
+ try {
+ cursor = resolver.query(uri, projection, null, null, null);
+ if (cursor == null || cursor.getCount() == 0) {
+ return null;
+ }
+
+ while (cursor.moveToNext()) {
+ long channelId = cursor.getLong(0);
+ String channelNumber = cursor.getString(1);
+ channelMap.put(channelId, getChannelByNumber(channelNumber, channels));
+ }
+ } catch (Exception e) {
+ Log.d(TAG, "Content provider query: " + e.getStackTrace());
+ return null;
+ } finally {
+ if (cursor != null) {
+ cursor.close();
+ }
+ }
+ return channelMap;
+ }
+
+ public static Channel getChannel(ContentResolver resolver, Uri channelUri) {
+ Cursor cursor = null;
+ try {
+ // TvProvider returns programs chronological order by default.
+ cursor = resolver.query(channelUri, null, null, null, null);
+ if (cursor == null || cursor.getCount() == 0) {
+ return null;
+ }
+ if (cursor.moveToNext()) {
+ return Channel.fromCursor(cursor);
+ }
+ } catch (Exception e) {
+ Log.w(TAG, "Unable to get channel for " + channelUri, e);
+ } finally {
+ if (cursor != null) {
+ cursor.close();
+ }
+ }
+ return null;
+ }
+
+ public static List getPrograms(ContentResolver resolver, Uri channelUri) {
+ Uri uri = TvContract.buildProgramsUriForChannel(channelUri);
+ Cursor cursor = null;
+ List programs = new ArrayList<>();
+ try {
+ // TvProvider returns programs chronological order by default.
+ cursor = resolver.query(uri, null, null, null, null);
+ if (cursor == null || cursor.getCount() == 0) {
+ return programs;
+ }
+ while (cursor.moveToNext()) {
+ programs.add(Program.fromCursor(cursor));
+ }
+ } catch (Exception e) {
+ Log.w(TAG, "Unable to get programs for " + channelUri, e);
+ } finally {
+ if (cursor != null) {
+ cursor.close();
+ }
+ }
+ return programs;
+ }
+
+ public static List getProgramPlaybackInfo(
+ ContentResolver resolver, Uri channelUri, long startTimeMs, long endTimeMs,
+ int maxProgramInReturn) {
+ Uri uri = TvContract.buildProgramsUriForChannel(channelUri, startTimeMs,
+ endTimeMs);
+ String[] projection = { Programs.COLUMN_START_TIME_UTC_MILLIS,
+ Programs.COLUMN_END_TIME_UTC_MILLIS,
+ Programs.COLUMN_CONTENT_RATING,
+ Programs.COLUMN_INTERNAL_PROVIDER_DATA,
+ Programs.COLUMN_CANONICAL_GENRE };
+ Cursor cursor = null;
+ List list = new ArrayList<>();
+ try {
+ cursor = resolver.query(uri, projection, null, null, null);
+ while (cursor != null && cursor.moveToNext()) {
+ long startMs = cursor.getLong(0);
+ long endMs = cursor.getLong(1);
+ TvContentRating[] ratings = stringToContentRatings(cursor.getString(2));
+ Pair values = parseInternalProviderData(cursor.getString(3));
+ int videoType = values.first;
+ String videoUrl = values.second;
+ list.add(new PlaybackInfo(startMs, endMs, videoUrl, videoType, ratings));
+ if (list.size() > maxProgramInReturn) {
+ break;
+ }
+ }
+ } catch (Exception e) {
+ Log.e(TAG, "Failed to get program playback info from TvProvider.", e);
+ } finally {
+ if (cursor != null) {
+ cursor.close();
+ }
+ }
+ return list;
+ }
+
+ public static String convertVideoInfoToInternalProviderData(int videotype, String videoUrl) {
+ return videotype + "," + videoUrl;
+ }
+
+ public static Pair parseInternalProviderData(String internalData) {
+ String[] values = internalData.split(",", 2);
+ if (values.length != 2) {
+ throw new IllegalArgumentException(internalData);
+ }
+ return new Pair<>(Integer.parseInt(values[0]), values[1]);
+ }
+
+ public static void insertUrl(Context context, Uri contentUri, URL sourceUrl) {
+ if (DEBUG) {
+ Log.d(TAG, "Inserting " + sourceUrl + " to " + contentUri);
+ }
+ InputStream is = null;
+ OutputStream os = null;
+ try {
+ is = sourceUrl.openStream();
+ os = context.getContentResolver().openOutputStream(contentUri);
+ copy(is, os);
+ } catch (IOException ioe) {
+ Log.e(TAG, "Failed to write " + sourceUrl + " to " + contentUri, ioe);
+ } finally {
+ if (is != null) {
+ try {
+ is.close();
+ } catch (IOException e) {
+ // Ignore exception.
+ }
+ }
+ if (os != null) {
+ try {
+ os.close();
+ } catch (IOException e) {
+ // Ignore exception.
+ }
+ }
+ }
+ }
+
+ public static void copy(InputStream is, OutputStream os) throws IOException {
+ byte[] buffer = new byte[1024];
+ int len;
+ while ((len = is.read(buffer)) != -1) {
+ os.write(buffer, 0, len);
+ }
+ }
+
+ public static TvContentRating[] stringToContentRatings(String commaSeparatedRatings) {
+ if (TextUtils.isEmpty(commaSeparatedRatings)) {
+ return null;
+ }
+ String[] ratings = commaSeparatedRatings.split("\\s*,\\s*");
+ TvContentRating[] contentRatings = new TvContentRating[ratings.length];
+ for (int i = 0; i < contentRatings.length; ++i) {
+ contentRatings[i] = TvContentRating.unflattenFromString(ratings[i]);
+ }
+ return contentRatings;
+ }
+
+ public static String contentRatingsToString(TvContentRating[] contentRatings) {
+ if (contentRatings == null || contentRatings.length == 0) {
+ return null;
+ }
+ final String DELIMITER = ",";
+ StringBuilder ratings = new StringBuilder(contentRatings[0].flattenToString());
+ for (int i = 1; i < contentRatings.length; ++i) {
+ ratings.append(DELIMITER);
+ ratings.append(contentRatings[i].flattenToString());
+ }
+ return ratings.toString();
+ }
+
+ private static XmlTvParser.XmlTvChannel getChannelByNumber(String channelNumber,
+ List channels) {
+ for (XmlTvParser.XmlTvChannel channel : channels) {
+ if (channelNumber.equals(channel.displayNumber)) {
+ return channel;
+ }
+ }
+ throw new IllegalArgumentException("Unknown channel: " + channelNumber);
+ }
+
+ public static class InsertLogosTask extends AsyncTask, Void, Void> {
+ private final Context context;
+
+ InsertLogosTask(Context context) {
+ this.context = context;
+ }
+
+ @Override
+ public Void doInBackground(Map... logosList) {
+ for (Map logos : logosList) {
+ for (Uri uri : logos.keySet()) {
+ try {
+ insertUrl(context, uri, new URL(logos.get(uri)));
+ } catch (MalformedURLException e) {
+ Log.e(TAG, "Can't load " + logos.get(uri), e);
+ }
+ }
+ }
+ return null;
+ }
+ }
+}
diff --git a/app/src/main/java/at/pansy/iptv/xmltv/XmlTvParser.java b/app/src/main/java/at/pansy/iptv/xmltv/XmlTvParser.java
new file mode 100644
index 0000000..7ee9adc
--- /dev/null
+++ b/app/src/main/java/at/pansy/iptv/xmltv/XmlTvParser.java
@@ -0,0 +1,392 @@
+/*
+ * Copyright 2015 The Android Open Source Project
+ *
+ * Licensed 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.
+ */
+
+package at.pansy.iptv.xmltv;
+
+import android.media.tv.TvContentRating;
+import android.text.TextUtils;
+import android.util.Xml;
+
+import com.google.android.exoplayer.ParserException;
+
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.List;
+
+import at.pansy.iptv.domain.PlaybackInfo;
+
+/**
+ * XMLTV document parser which conforms to http://wiki.xmltv.org/index.php/Main_Page
+ *
+ * Please note that xmltv.dtd are extended to be align with Android TV Input Framework and
+ * contain static video contents:
+ *
+ *
+ *
+ *
+ * video-type CDATA #IMPLIED >
+ *
+ * display-number : The channel number that is displayed to the user.
+ * repeat-programs : If "true", the programs in the xml document are scheduled sequentially in a
+ * loop regardless of their start and end time. This is introduced to simulate a live
+ * channel in this sample.
+ * video-src : The video URL for the given program. This can be omitted if the xml will be used
+ * only for the program guide update.
+ * video-type : The video type. Should be one of "HTTP_PROGRESSIVE", "HLS", and "MPEG-DASH". This
+ * can be omitted if the xml will be used only for the program guide update.
+ */
+public class XmlTvParser {
+ private static final String TAG_TV = "tv";
+ private static final String TAG_CHANNEL = "channel";
+ private static final String TAG_DISPLAY_NAME = "display-name";
+ private static final String TAG_ICON = "icon";
+ private static final String TAG_PROGRAM = "programme";
+ private static final String TAG_TITLE = "title";
+ private static final String TAG_DESC = "desc";
+ private static final String TAG_CATEGORY = "category";
+ private static final String TAG_RATING = "rating";
+ private static final String TAG_VALUE = "value";
+ private static final String TAG_DISPLAY_NUMBER = "display-number";
+
+ private static final String ATTR_ID = "id";
+ private static final String ATTR_START = "start";
+ private static final String ATTR_STOP = "stop";
+ private static final String ATTR_CHANNEL = "channel";
+ private static final String ATTR_SYSTEM = "system";
+ private static final String ATTR_SRC = "src";
+ private static final String ATTR_REPEAT_PROGRAMS = "repeat-programs";
+ private static final String ATTR_VIDEO_SRC = "video-src";
+ private static final String ATTR_VIDEO_TYPE = "video-type";
+
+ private static final String VALUE_VIDEO_TYPE_HTTP_PROGRESSIVE = "HTTP_PROGRESSIVE";
+ private static final String VALUE_VIDEO_TYPE_HLS = "HLS";
+ private static final String VALUE_VIDEO_TYPE_MPEG_DASH = "MPEG_DASH";
+
+ private static final String ANDROID_TV_RATING = "com.android.tv";
+
+ private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyyMMddHHmmss Z");
+
+ private XmlTvParser() {
+ }
+
+ public static TvContentRating[] xmlTvRatingToTvContentRating(
+ XmlTvRating[] ratings) {
+ List list = new ArrayList<>();
+ for (XmlTvRating rating : ratings) {
+ if (ANDROID_TV_RATING.equals(rating.system)) {
+ list.add(TvContentRating.unflattenFromString(rating.value));
+ }
+ }
+ return list.toArray(new TvContentRating[list.size()]);
+ }
+
+ public static TvListing parse(InputStream inputStream) {
+ try {
+ XmlPullParser parser = Xml.newPullParser();
+ parser.setInput(inputStream, null);
+ int eventType = parser.next();
+ if (eventType != XmlPullParser.START_TAG || !TAG_TV.equals(parser.getName())) {
+ throw new ParserException(
+ "inputStream does not contain a xml tv description");
+ }
+ return parseTvListings(parser);
+ } catch (XmlPullParserException | IOException | ParseException e) {
+ e.printStackTrace();
+ }
+ return null;
+ }
+
+ private static TvListing parseTvListings(XmlPullParser parser)
+ throws IOException, XmlPullParserException, ParseException {
+ List channels = new ArrayList<>();
+ List programs = new ArrayList<>();
+ while (parser.next() != XmlPullParser.END_DOCUMENT) {
+ if (parser.getEventType() == XmlPullParser.START_TAG
+ && TAG_CHANNEL.equalsIgnoreCase(parser.getName())) {
+ channels.add(parseChannel(parser));
+ }
+ if (parser.getEventType() == XmlPullParser.START_TAG
+ && TAG_PROGRAM.equalsIgnoreCase(parser.getName())) {
+ programs.add(parseProgram(parser));
+ }
+ }
+ return new TvListing(channels, programs);
+ }
+
+ private static XmlTvChannel parseChannel(XmlPullParser parser)
+ throws IOException, XmlPullParserException {
+ String id = null;
+ boolean repeatPrograms = false;
+ for (int i = 0; i < parser.getAttributeCount(); ++i) {
+ String attr = parser.getAttributeName(i);
+ String value = parser.getAttributeValue(i);
+ if (ATTR_ID.equalsIgnoreCase(attr)) {
+ id = value;
+ } else if (ATTR_REPEAT_PROGRAMS.equalsIgnoreCase(attr)) {
+ repeatPrograms = "TRUE".equalsIgnoreCase(value);
+ }
+ }
+ String displayName = null;
+ String displayNumber = null;
+ XmlTvIcon icon = null;
+ while (parser.next() != XmlPullParser.END_DOCUMENT) {
+ if (parser.getEventType() == XmlPullParser.START_TAG) {
+ if (TAG_DISPLAY_NAME.equalsIgnoreCase(parser.getName())
+ && displayName == null) {
+ // TODO: support multiple display names.
+ displayName = parser.nextText();
+ } else if (TAG_DISPLAY_NUMBER.equalsIgnoreCase(parser.getName())
+ && displayNumber == null) {
+ displayNumber = parser.nextText();
+ } else if (TAG_ICON.equalsIgnoreCase(parser.getName()) && icon == null) {
+ icon = parseIcon(parser);
+ }
+ } else if (TAG_CHANNEL.equalsIgnoreCase(parser.getName())
+ && parser.getEventType() == XmlPullParser.END_TAG) {
+ break;
+ }
+ }
+ if (TextUtils.isEmpty(id) || TextUtils.isEmpty(displayName)) {
+ throw new IllegalArgumentException("id and display-name can not be null.");
+ }
+
+ // Developers should assign original network ID in the right way not using the fake ID.
+ int fakeOriginalNetworkId = (displayNumber + displayName).hashCode();
+ return new XmlTvChannel(id, displayName, displayNumber, icon, fakeOriginalNetworkId, 0, 0,
+ repeatPrograms);
+ }
+
+ private static XmlTvProgram parseProgram(XmlPullParser parser)
+ throws IOException, XmlPullParserException, ParseException {
+ String channelId = null;
+ Long startTimeUtcMillis = null;
+ Long endTimeUtcMillis = null;
+ String videoSrc = null;
+ int videoType = PlaybackInfo.VIDEO_TYPE_HLS;
+ for (int i = 0; i < parser.getAttributeCount(); ++i) {
+ String attr = parser.getAttributeName(i);
+ String value = parser.getAttributeValue(i);
+ if (ATTR_CHANNEL.equalsIgnoreCase(attr)) {
+ channelId = value;
+ } else if (ATTR_START.equalsIgnoreCase(attr)) {
+ startTimeUtcMillis = DATE_FORMAT.parse(value).getTime();
+ } else if (ATTR_STOP.equalsIgnoreCase(attr)) {
+ endTimeUtcMillis = DATE_FORMAT.parse(value).getTime();
+ } else if (ATTR_VIDEO_SRC.equalsIgnoreCase(attr)) {
+ videoSrc = value;
+ } else if (ATTR_VIDEO_TYPE.equalsIgnoreCase(attr)) {
+ if (VALUE_VIDEO_TYPE_HTTP_PROGRESSIVE.equals(value)) {
+ videoType = PlaybackInfo.VIDEO_TYPE_HTTP_PROGRESSIVE;
+ } else if (VALUE_VIDEO_TYPE_HLS.equals(value)) {
+ videoType = PlaybackInfo.VIDEO_TYPE_HLS;
+ } else if (VALUE_VIDEO_TYPE_MPEG_DASH.equals(value)) {
+ videoType = PlaybackInfo.VIDEO_TYPE_MPEG_DASH;
+ }
+ }
+ }
+ String title = null;
+ String description = null;
+ XmlTvIcon icon = null;
+ List category = new ArrayList<>();
+ List rating = new ArrayList<>();
+ while (parser.next() != XmlPullParser.END_DOCUMENT) {
+ String tagName = parser.getName();
+ if (parser.getEventType() == XmlPullParser.START_TAG) {
+ if (TAG_TITLE.equalsIgnoreCase(parser.getName())) {
+ title = parser.nextText();
+ } else if (TAG_DESC.equalsIgnoreCase(tagName)) {
+ description = parser.nextText();
+ } else if (TAG_ICON.equalsIgnoreCase(tagName)) {
+ icon = parseIcon(parser);
+ } else if (TAG_CATEGORY.equalsIgnoreCase(tagName)) {
+ category.add(parser.nextText());
+ } else if (TAG_RATING.equalsIgnoreCase(tagName)) {
+ try {
+ rating.add(parseRating(parser));
+ } catch (IllegalArgumentException e) {
+ // do not add wrong rating values
+ }
+ }
+ } else if (TAG_PROGRAM.equalsIgnoreCase(tagName)
+ && parser.getEventType() == XmlPullParser.END_TAG) {
+ break;
+ }
+ }
+ if (TextUtils.isEmpty(channelId) || startTimeUtcMillis == null
+ || endTimeUtcMillis == null) {
+ throw new IllegalArgumentException("channel, start, and end can not be null.");
+ }
+ return new XmlTvProgram(channelId, title, description, icon,
+ category.toArray(new String[category.size()]), startTimeUtcMillis, endTimeUtcMillis,
+ rating.toArray(new XmlTvRating[rating.size()]), videoSrc, videoType);
+ }
+
+ private static XmlTvIcon parseIcon(XmlPullParser parser)
+ throws IOException, XmlPullParserException {
+ String src = null;
+ for (int i = 0; i < parser.getAttributeCount(); ++i) {
+ String attr = parser.getAttributeName(i);
+ String value = parser.getAttributeValue(i);
+ if (ATTR_SRC.equalsIgnoreCase(attr)) {
+ src = value;
+ }
+ }
+ while (parser.next() != XmlPullParser.END_DOCUMENT) {
+ if (TAG_ICON.equalsIgnoreCase(parser.getName())
+ && parser.getEventType() == XmlPullParser.END_TAG) {
+ break;
+ }
+ }
+ if (TextUtils.isEmpty(src)) {
+ throw new IllegalArgumentException("src cannot be null.");
+ }
+ return new XmlTvIcon(src);
+ }
+
+ private static XmlTvRating parseRating(XmlPullParser parser)
+ throws IOException, XmlPullParserException {
+ String system = null;
+ for (int i = 0; i < parser.getAttributeCount(); ++i) {
+ String attr = parser.getAttributeName(i);
+ String value = parser.getAttributeValue(i);
+ if (ATTR_SYSTEM.equalsIgnoreCase(attr)) {
+ system = value;
+ }
+ }
+ String value = null;
+ while (parser.next() != XmlPullParser.END_DOCUMENT) {
+ if (parser.getEventType() == XmlPullParser.START_TAG) {
+ if (TAG_VALUE.equalsIgnoreCase(parser.getName())) {
+ value = parser.nextText();
+ }
+ } else if (TAG_RATING.equalsIgnoreCase(parser.getName())
+ && parser.getEventType() == XmlPullParser.END_TAG) {
+ break;
+ }
+ }
+ if (TextUtils.isEmpty(system) || TextUtils.isEmpty(value)) {
+ throw new IllegalArgumentException("system and value cannot be null.");
+ }
+ return new XmlTvRating(system, value);
+ }
+
+ public static class TvListing {
+ public List channels;
+ public final List programs;
+
+ public TvListing(List channels, List programs) {
+ this.channels = channels;
+ this.programs = programs;
+ }
+
+ public void setChannels(List channels) {
+ this.channels = channels;
+ }
+ }
+
+ public static class XmlTvChannel {
+ public final String id;
+ public final String displayName;
+ public final String displayNumber;
+ public final XmlTvIcon icon;
+ public final int originalNetworkId;
+ public final int transportStreamId;
+ public final int serviceId;
+ public final boolean repeatPrograms;
+ public String url;
+
+ public XmlTvChannel(String id, String displayName, String displayNumber, XmlTvIcon icon,
+ int originalNetworkId, int transportStreamId, int serviceId,
+ boolean repeatPrograms) {
+ this(id, displayName, displayNumber, icon, originalNetworkId, transportStreamId,
+ serviceId, repeatPrograms, null);
+ }
+
+ public XmlTvChannel(String id, String displayName, String displayNumber, XmlTvIcon icon,
+ int originalNetworkId, int transportStreamId, int serviceId,
+ boolean repeatPrograms, String url) {
+ this.id = id;
+ this.displayName = displayName;
+ this.displayNumber = displayNumber;
+ this.icon = icon;
+ this.originalNetworkId = originalNetworkId;
+ this.transportStreamId = transportStreamId;
+ this.serviceId = serviceId;
+ this.repeatPrograms = repeatPrograms;
+ this.url = url;
+ }
+ }
+
+ public static class XmlTvProgram {
+ public final String channelId;
+ public final String title;
+ public final String description;
+ public final XmlTvIcon icon;
+ public final String[] category;
+ public final long startTimeUtcMillis;
+ public final long endTimeUtcMillis;
+ public final XmlTvRating[] rating;
+ public final String videoSrc;
+ public final int videoType;
+
+ private XmlTvProgram(String channelId, String title, String description, XmlTvIcon icon,
+ String[] category, long startTimeUtcMillis, long endTimeUtcMillis,
+ XmlTvRating[] rating, String videoSrc, int videoType) {
+ this.channelId = channelId;
+ this.title = title;
+ this.description = description;
+ this.icon = icon;
+ this.category = category;
+ this.startTimeUtcMillis = startTimeUtcMillis;
+ this.endTimeUtcMillis = endTimeUtcMillis;
+ this.rating = rating;
+ this.videoSrc = videoSrc;
+ this.videoType = videoType;
+ }
+
+ public long getDurationMillis() {
+ return endTimeUtcMillis - startTimeUtcMillis;
+ }
+ }
+
+ public static class XmlTvIcon {
+ public final String src;
+
+ public XmlTvIcon(String src) {
+ this.src = src;
+ }
+ }
+
+ public static class XmlTvRating {
+ public final String system;
+ public final String value;
+
+ public XmlTvRating(String system, String value) {
+ this.system = system;
+ this.value = value;
+ }
+ }
+}
diff --git a/app/src/main/res/drawable-mdpi/default_background.xml b/app/src/main/res/drawable-mdpi/default_background.xml
new file mode 100644
index 0000000..07b0589
--- /dev/null
+++ b/app/src/main/res/drawable-mdpi/default_background.xml
@@ -0,0 +1,9 @@
+
+
+
+
+
\ No newline at end of file
diff --git a/app/src/main/res/drawable-mdpi/ic_launcher.png b/app/src/main/res/drawable-mdpi/ic_launcher.png
new file mode 100644
index 0000000..359047d
Binary files /dev/null and b/app/src/main/res/drawable-mdpi/ic_launcher.png differ
diff --git a/app/src/main/res/drawable-xhdpi/ic_launcher.png b/app/src/main/res/drawable-xhdpi/ic_launcher.png
new file mode 100644
index 0000000..71c6d76
Binary files /dev/null and b/app/src/main/res/drawable-xhdpi/ic_launcher.png differ
diff --git a/app/src/main/res/layout/overlay_view.xml b/app/src/main/res/layout/overlay_view.xml
new file mode 100644
index 0000000..91ec5f9
--- /dev/null
+++ b/app/src/main/res/layout/overlay_view.xml
@@ -0,0 +1,33 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/app/src/main/res/layout/setup_activity.xml b/app/src/main/res/layout/setup_activity.xml
new file mode 100644
index 0000000..8c9cc71
--- /dev/null
+++ b/app/src/main/res/layout/setup_activity.xml
@@ -0,0 +1,21 @@
+
+
+
diff --git a/app/src/main/res/mipmap-hdpi/ic_launcher.png b/app/src/main/res/mipmap-hdpi/ic_launcher.png
new file mode 100644
index 0000000..cde69bc
Binary files /dev/null and b/app/src/main/res/mipmap-hdpi/ic_launcher.png differ
diff --git a/app/src/main/res/mipmap-mdpi/ic_launcher.png b/app/src/main/res/mipmap-mdpi/ic_launcher.png
new file mode 100644
index 0000000..c133a0c
Binary files /dev/null and b/app/src/main/res/mipmap-mdpi/ic_launcher.png differ
diff --git a/app/src/main/res/mipmap-xhdpi/ic_launcher.png b/app/src/main/res/mipmap-xhdpi/ic_launcher.png
new file mode 100644
index 0000000..bfa42f0
Binary files /dev/null and b/app/src/main/res/mipmap-xhdpi/ic_launcher.png differ
diff --git a/app/src/main/res/mipmap-xxhdpi/ic_launcher.png b/app/src/main/res/mipmap-xxhdpi/ic_launcher.png
new file mode 100644
index 0000000..324e72c
Binary files /dev/null and b/app/src/main/res/mipmap-xxhdpi/ic_launcher.png differ
diff --git a/app/src/main/res/values/colors.xml b/app/src/main/res/values/colors.xml
new file mode 100644
index 0000000..e9e5c7f
--- /dev/null
+++ b/app/src/main/res/values/colors.xml
@@ -0,0 +1,18 @@
+
+ #000000
+ #DDDDDD
+ #0096a6
+ #ffaa3f
+ #ffaa3f
+ #0096a6
+ #30000000
+ #30FF0000
+ #00000000
+ #AA000000
+ #59000000
+ #FFFFFF
+ #AAFADCA7
+ #FADCA7
+ #EEFF41
+ #3d3d3d
+
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
new file mode 100644
index 0000000..4c8025f
--- /dev/null
+++ b/app/src/main/res/values/strings.xml
@@ -0,0 +1,15 @@
+
+ IPTV Live Channels
+ IPTV Live Channels
+
+ http://tv.iptv.ink/iptv.ink
+ http://epg.iptv.ink/iptv.epg.gz
+ http://logo.iptv.ink/
+
+ Add Channels
+ Update Channels
+ Cancel Setup
+ In Progress…
+ TV Inputs by Your Company
+ No feed. Check your connection!
+
diff --git a/app/src/main/res/values/styles.xml b/app/src/main/res/values/styles.xml
new file mode 100644
index 0000000..49d6086
--- /dev/null
+++ b/app/src/main/res/values/styles.xml
@@ -0,0 +1,4 @@
+
+
+
+
diff --git a/app/src/main/res/values/themes.xml b/app/src/main/res/values/themes.xml
new file mode 100644
index 0000000..cc8a824
--- /dev/null
+++ b/app/src/main/res/values/themes.xml
@@ -0,0 +1,12 @@
+
+
+
diff --git a/app/src/main/res/xml/authenticator.xml b/app/src/main/res/xml/authenticator.xml
new file mode 100644
index 0000000..ab47229
--- /dev/null
+++ b/app/src/main/res/xml/authenticator.xml
@@ -0,0 +1,20 @@
+
+
+
diff --git a/app/src/main/res/xml/syncadapter.xml b/app/src/main/res/xml/syncadapter.xml
new file mode 100644
index 0000000..d739584
--- /dev/null
+++ b/app/src/main/res/xml/syncadapter.xml
@@ -0,0 +1,22 @@
+
+
+
diff --git a/app/src/main/res/xml/tvinputservice.xml b/app/src/main/res/xml/tvinputservice.xml
new file mode 100644
index 0000000..6e07bb3
--- /dev/null
+++ b/app/src/main/res/xml/tvinputservice.xml
@@ -0,0 +1,18 @@
+
+
+
diff --git a/build.gradle b/build.gradle
new file mode 100644
index 0000000..be515a8
--- /dev/null
+++ b/build.gradle
@@ -0,0 +1,23 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+
+buildscript {
+ repositories {
+ jcenter()
+ }
+ dependencies {
+ classpath 'com.android.tools.build:gradle:1.3.0'
+
+ // NOTE: Do not place your application dependencies here; they belong
+ // in the individual module build.gradle files
+ }
+}
+
+allprojects {
+ repositories {
+ jcenter()
+ }
+}
+
+task clean(type: Delete) {
+ delete rootProject.buildDir
+}
diff --git a/gradle.properties b/gradle.properties
new file mode 100644
index 0000000..1d3591c
--- /dev/null
+++ b/gradle.properties
@@ -0,0 +1,18 @@
+# Project-wide Gradle settings.
+
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
+
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+# Default value: -Xmx10248m -XX:MaxPermSize=256m
+# org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
+
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# org.gradle.parallel=true
\ No newline at end of file
diff --git a/settings.gradle b/settings.gradle
new file mode 100644
index 0000000..e7b4def
--- /dev/null
+++ b/settings.gradle
@@ -0,0 +1 @@
+include ':app'