livefootballtv-tizen 1.0.0

package/app/native_service/README.md

@@ -0,0 +1,94 @@
+# LiveFootballTV C++ Proxy Service - Tizen Studio Setup
+
+This directory contains the source code for the native C++ proxy service. 
+You need to create a Tizen Studio project and import these files.
+
+## Quick Setup in Tizen Studio
+
+### Step 1: Create New Native Service Project
+
+1. Open Tizen Studio
+2. File → New → Tizen Project
+3. Select **Template** → **TV** → **Native Service**
+4. Name it: `proxyservice`
+5. Package ID: `LIVEFTV001` (must match the web app!)
+
+### Step 2: Configure C++11
+
+1. Right-click project → **Properties**
+2. Go to: C/C++ Build → Settings → Tool Settings → C++ Compiler → Dialect
+3. Set Language standard to: **ISO C++11 (-std=c++0x)**
+4. Click **Apply and Close**
+
+### Step 3: Copy Source Files
+
+Copy these files into your Tizen Studio project:
+
+```
+From: d:\IDE AI\webapp\tizen\native_service\
+  ├── tizen-manifest.xml  →  [project root]/tizen-manifest.xml
+  ├── src/proxy_service.cpp  →  [project root]/src/proxy_service.cpp
+  └── inc/proxy_service.h  →  [project root]/inc/proxy_service.h
+```
+
+### Step 4: Add Required Libraries
+
+In project Properties → C/C++ Build → Settings → Tool Settings → C++ Linker → Libraries:
+
+Add these libraries (`-l` flags):
+- `curl`
+- `pthread`
+
+### Step 5: Build the Native Service
+
+1. Right-click project → **Build Project**
+2. Ensure no compilation errors
+
+### Step 6: Create Hybrid Package
+
+To package both web app and native service together:
+
+1. Right-click the **Web App** project (livefootballtv)
+2. Select: **Export to TPK**
+3. In the dialog, check "Include Native Service"
+4. Select the `proxyservice` native project
+5. Export the combined `.wgt` or `.tpk` file
+
+### Step 7: Deploy and Test
+
+1. Connect TV via SDB
+2. Install the hybrid package
+3. Launch the app
+4. Check if the Proxy indicator turns green
+
+## Endpoints
+
+The service runs on `http://localhost:8888` with these endpoints:
+
+| Endpoint | Description |
+|----------|-------------|
+| `/health` | Health check - returns `{"status":"ok"}` |
+| `/proxy?url=...` | Proxy request with custom headers |
+
+## Custom Headers
+
+Pass these headers to add custom headers to proxied requests:
+
+- `X-Proxy-Referer: https://example.com` → Sends `Referer: https://example.com`
+- `X-Proxy-Origin: https://example.com` → Sends `Origin: https://example.com`
+- `X-Proxy-User-Agent: Custom UA` → Sends `User-Agent: Custom UA`
+
+## Troubleshooting
+
+### Service Not Starting
+- Check Tizen Studio console for errors
+- Verify package ID matches between web app and native service
+- Ensure all privileges are granted
+
+### Port Already in Use
+- Another instance may be running
+- Restart the TV and try again
+
+### CURL Errors
+- Check internet connectivity
+- Verify target URL is accessible

package/app/native_service/inc/proxy_service.h

@@ -0,0 +1,22 @@
+/**
+ * LiveFootballTV Proxy Service - Header
+ */
+
+#ifndef __PROXY_SERVICE_H__
+#define __PROXY_SERVICE_H__
+
+#include <service_app.h>
+#include <dlog.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define LOG_TAG "PROXY_SERVICE"
+#define PROXY_PORT 8888
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __PROXY_SERVICE_H__ */

package/app/native_service/src/proxy_service.cpp

@@ -0,0 +1,453 @@
+/**
+ * LiveFootballTV C++ Proxy Service
+ * 
+ * This native service runs on localhost:8888 and proxies HTTP requests
+ * with custom headers for streaming video content.
+ * 
+ * Build with Tizen Studio -> TV Native Service Project
+ * Enable C++11 in Project Settings
+ */
+
+#include <service_app.h>
+#include <dlog.h>
+#include <curl/curl.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <cstring>
+#include <string>
+#include <sstream>
+#include <map>
+#include <vector>
+
+#define LOG_TAG "PROXY_SERVICE"
+#define PROXY_PORT 8888
+#define BUFFER_SIZE 65536
+#define MAX_CLIENTS 10
+
+static int server_fd = -1;
+static volatile bool running = false;
+static pthread_t server_thread;
+
+// ============================================================================
+// CURL Helpers
+// ============================================================================
+
+struct CurlResponse {
+    std::vector<char> data;
+    std::string content_type;
+    long http_code;
+};
+
+static size_t write_callback(void* contents, size_t size, size_t nmemb, void* userp) {
+    CurlResponse* response = static_cast<CurlResponse*>(userp);
+    size_t total_size = size * nmemb;
+    const char* data = static_cast<char*>(contents);
+    response->data.insert(response->data.end(), data, data + total_size);
+    return total_size;
+}
+
+static size_t header_callback(char* buffer, size_t size, size_t nitems, void* userp) {
+    CurlResponse* response = static_cast<CurlResponse*>(userp);
+    size_t total_size = size * nitems;
+    std::string header(buffer, total_size);
+    
+    // Parse Content-Type header
+    if (header.find("Content-Type:") == 0 || header.find("content-type:") == 0) {
+        size_t start = header.find(':') + 1;
+        size_t end = header.find('\r');
+        if (end == std::string::npos) end = header.find('\n');
+        if (end != std::string::npos) {
+            response->content_type = header.substr(start, end - start);
+            // Trim whitespace
+            size_t first = response->content_type.find_first_not_of(" \t");
+            if (first != std::string::npos) {
+                response->content_type = response->content_type.substr(first);
+            }
+        }
+    }
+    return total_size;
+}
+
+// ============================================================================
+// HTTP Parsing Helpers
+// ============================================================================
+
+std::string url_decode(const std::string& encoded) {
+    CURL* curl = curl_easy_init();
+    if (!curl) return encoded;
+    
+    int out_len;
+    char* decoded = curl_easy_unescape(curl, encoded.c_str(), encoded.length(), &out_len);
+    std::string result = decoded ? std::string(decoded, out_len) : encoded;
+    if (decoded) curl_free(decoded);
+    curl_easy_cleanup(curl);
+    return result;
+}
+
+std::string parse_url_param(const std::string& request) {
+    // Find ?url= or &url= in the request
+    size_t url_start = request.find("url=");
+    if (url_start == std::string::npos) return "";
+    
+    url_start += 4; // Skip "url="
+    
+    // Find the end of the URL parameter (space or &)
+    size_t url_end = request.find_first_of(" &\r\n", url_start);
+    if (url_end == std::string::npos) url_end = request.length();
+    
+    std::string url = request.substr(url_start, url_end - url_start);
+    return url_decode(url);
+}
+
+std::map<std::string, std::string> parse_custom_headers(const std::string& request) {
+    std::map<std::string, std::string> headers;
+    
+    // Parse headers that start with X-Proxy- prefix
+    // These will be forwarded without the prefix
+    const char* prefixes[] = {"X-Proxy-Referer:", "X-Proxy-Origin:", "X-Proxy-User-Agent:"};
+    const char* header_names[] = {"Referer", "Origin", "User-Agent"};
+    
+    for (int i = 0; i < 3; i++) {
+        size_t pos = request.find(prefixes[i]);
+        if (pos != std::string::npos) {
+            size_t value_start = pos + strlen(prefixes[i]);
+            // Skip leading whitespace
+            while (value_start < request.length() && 
+                   (request[value_start] == ' ' || request[value_start] == '\t')) {
+                value_start++;
+            }
+            size_t value_end = request.find("\r\n", value_start);
+            if (value_end == std::string::npos) value_end = request.find("\n", value_start);
+            if (value_end != std::string::npos) {
+                headers[header_names[i]] = request.substr(value_start, value_end - value_start);
+            }
+        }
+    }
+    
+    return headers;
+}
+
+// ============================================================================
+// HTTP Response Helpers
+// ============================================================================
+
+void send_response(int client_fd, int status_code, const char* status_text,
+                   const char* content_type, const char* body, size_t body_len) {
+    std::ostringstream response;
+    response << "HTTP/1.1 " << status_code << " " << status_text << "\r\n";
+    response << "Access-Control-Allow-Origin: *\r\n";
+    response << "Access-Control-Allow-Methods: GET, POST, OPTIONS\r\n";
+    response << "Access-Control-Allow-Headers: *\r\n";
+    response << "Access-Control-Expose-Headers: *\r\n";
+    response << "Connection: close\r\n";
+    if (content_type) {
+        response << "Content-Type: " << content_type << "\r\n";
+    }
+    response << "Content-Length: " << body_len << "\r\n";
+    response << "\r\n";
+    
+    std::string headers = response.str();
+    send(client_fd, headers.c_str(), headers.length(), 0);
+    if (body && body_len > 0) {
+        send(client_fd, body, body_len, 0);
+    }
+}
+
+void send_json_response(int client_fd, int status_code, const char* status_text, const char* json) {
+    send_response(client_fd, status_code, status_text, "application/json", json, strlen(json));
+}
+
+// ============================================================================
+// Request Handlers
+// ============================================================================
+
+void handle_health_check(int client_fd) {
+    const char* json = "{\"status\":\"ok\",\"service\":\"LiveFootballTV Proxy\",\"port\":8888}";
+    send_json_response(client_fd, 200, "OK", json);
+    dlog_print(DLOG_DEBUG, LOG_TAG, "Health check: OK");
+}
+
+void handle_cors_preflight(int client_fd) {
+    send_response(client_fd, 200, "OK", NULL, "", 0);
+    dlog_print(DLOG_DEBUG, LOG_TAG, "CORS preflight handled");
+}
+
+void handle_proxy_request(int client_fd, const std::string& request) {
+    // Extract target URL
+    std::string target_url = parse_url_param(request);
+    if (target_url.empty()) {
+        const char* error = "{\"error\":\"Missing 'url' parameter\"}";
+        send_json_response(client_fd, 400, "Bad Request", error);
+        return;
+    }
+    
+    dlog_print(DLOG_INFO, LOG_TAG, "Proxying: %s", target_url.c_str());
+    
+    // Parse custom headers from request
+    auto custom_headers = parse_custom_headers(request);
+    
+    // Initialize CURL
+    CURL* curl = curl_easy_init();
+    if (!curl) {
+        const char* error = "{\"error\":\"Failed to initialize HTTP client\"}";
+        send_json_response(client_fd, 500, "Internal Server Error", error);
+        return;
+    }
+    
+    CurlResponse response;
+    response.http_code = 0;
+    
+    // Build headers list
+    struct curl_slist* curl_headers = NULL;
+    
+    // Add custom headers from request
+    for (const auto& h : custom_headers) {
+        std::string header = h.first + ": " + h.second;
+        curl_headers = curl_slist_append(curl_headers, header.c_str());
+        dlog_print(DLOG_DEBUG, LOG_TAG, "Adding header: %s", header.c_str());
+    }
+    
+    // Default User-Agent if not provided
+    if (custom_headers.find("User-Agent") == custom_headers.end()) {
+        curl_headers = curl_slist_append(curl_headers, 
+            "User-Agent: Mozilla/5.0 (SMART-TV; Tizen 4.0) AppleWebKit/538.1 (KHTML, like Gecko)");
+    }
+    
+    // Configure CURL
+    curl_easy_setopt(curl, CURLOPT_URL, target_url.c_str());
+    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, curl_headers);
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
+    curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, header_callback);
+    curl_easy_setopt(curl, CURLOPT_HEADERDATA, &response);
+    curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
+    curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 10L);
+    curl_easy_setopt(curl, CURLOPT_TIMEOUT, 30L);
+    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 10L);
+    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
+    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
+    
+    // Perform request
+    CURLcode res = curl_easy_perform(curl);
+    
+    if (res == CURLE_OK) {
+        curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response.http_code);
+        
+        dlog_print(DLOG_INFO, LOG_TAG, "Proxy response: %ld, size: %zu", 
+                   response.http_code, response.data.size());
+        
+        // Determine content type
+        const char* ct = response.content_type.empty() ? 
+                        "application/octet-stream" : response.content_type.c_str();
+        
+        // Send response
+        send_response(client_fd, (int)response.http_code, "OK", ct,
+                     response.data.data(), response.data.size());
+    } else {
+        dlog_print(DLOG_ERROR, LOG_TAG, "CURL error: %s", curl_easy_strerror(res));
+        
+        std::ostringstream error_json;
+        error_json << "{\"error\":\"" << curl_easy_strerror(res) << "\"}";
+        std::string error_str = error_json.str();
+        send_json_response(client_fd, 502, "Bad Gateway", error_str.c_str());
+    }
+    
+    // Cleanup
+    if (curl_headers) curl_slist_free_all(curl_headers);
+    curl_easy_cleanup(curl);
+}
+
+// ============================================================================
+// Client Handler
+// ============================================================================
+
+void handle_client(int client_fd) {
+    char buffer[BUFFER_SIZE];
+    ssize_t bytes_read = recv(client_fd, buffer, sizeof(buffer) - 1, 0);
+    
+    if (bytes_read <= 0) {
+        close(client_fd);
+        return;
+    }
+    
+    buffer[bytes_read] = '\0';
+    std::string request(buffer);
+    
+    dlog_print(DLOG_DEBUG, LOG_TAG, "Request received (%zd bytes)", bytes_read);
+    
+    // Route request
+    if (request.find("GET /health") != std::string::npos) {
+        handle_health_check(client_fd);
+    }
+    else if (request.find("OPTIONS ") == 0) {
+        handle_cors_preflight(client_fd);
+    }
+    else if (request.find("/proxy?") != std::string::npos || 
+             request.find("/proxy?") != std::string::npos) {
+        handle_proxy_request(client_fd, request);
+    }
+    else {
+        const char* error = "{\"error\":\"Unknown endpoint. Use /health or /proxy?url=...\"}";
+        send_json_response(client_fd, 404, "Not Found", error);
+    }
+    
+    close(client_fd);
+}
+
+// ============================================================================
+// Server Thread
+// ============================================================================
+
+void* server_loop(void* arg) {
+    dlog_print(DLOG_INFO, LOG_TAG, "Server thread started");
+    
+    while (running) {
+        struct sockaddr_in client_addr;
+        socklen_t client_len = sizeof(client_addr);
+        
+        // Use select with timeout to allow checking 'running' flag
+        fd_set read_fds;
+        FD_ZERO(&read_fds);
+        FD_SET(server_fd, &read_fds);
+        
+        struct timeval timeout;
+        timeout.tv_sec = 1;
+        timeout.tv_usec = 0;
+        
+        int ready = select(server_fd + 1, &read_fds, NULL, NULL, &timeout);
+        
+        if (ready > 0 && FD_ISSET(server_fd, &read_fds)) {
+            int client_fd = accept(server_fd, (struct sockaddr*)&client_addr, &client_len);
+            if (client_fd >= 0) {
+                handle_client(client_fd);
+            }
+        }
+    }
+    
+    dlog_print(DLOG_INFO, LOG_TAG, "Server thread exiting");
+    return NULL;
+}
+
+// ============================================================================
+// Server Start/Stop
+// ============================================================================
+
+bool start_server() {
+    server_fd = socket(AF_INET, SOCK_STREAM, 0);
+    if (server_fd < 0) {
+        dlog_print(DLOG_ERROR, LOG_TAG, "Socket creation failed: %s", strerror(errno));
+        return false;
+    }
+    
+    // Allow address reuse
+    int opt = 1;
+    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
+        dlog_print(DLOG_WARN, LOG_TAG, "setsockopt SO_REUSEADDR failed");
+    }
+    
+    // Bind to all interfaces on PROXY_PORT
+    struct sockaddr_in server_addr;
+    memset(&server_addr, 0, sizeof(server_addr));
+    server_addr.sin_family = AF_INET;
+    server_addr.sin_addr.s_addr = INADDR_ANY;
+    server_addr.sin_port = htons(PROXY_PORT);
+    
+    if (bind(server_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
+        dlog_print(DLOG_ERROR, LOG_TAG, "Bind failed on port %d: %s", PROXY_PORT, strerror(errno));
+        close(server_fd);
+        server_fd = -1;
+        return false;
+    }
+    
+    if (listen(server_fd, MAX_CLIENTS) < 0) {
+        dlog_print(DLOG_ERROR, LOG_TAG, "Listen failed: %s", strerror(errno));
+        close(server_fd);
+        server_fd = -1;
+        return false;
+    }
+    
+    running = true;
+    
+    if (pthread_create(&server_thread, NULL, server_loop, NULL) != 0) {
+        dlog_print(DLOG_ERROR, LOG_TAG, "Failed to create server thread");
+        close(server_fd);
+        server_fd = -1;
+        running = false;
+        return false;
+    }
+    
+    dlog_print(DLOG_INFO, LOG_TAG, "=== Proxy Server Started on port %d ===", PROXY_PORT);
+    return true;
+}
+
+void stop_server() {
+    dlog_print(DLOG_INFO, LOG_TAG, "Stopping proxy server...");
+    
+    running = false;
+    
+    if (server_fd >= 0) {
+        shutdown(server_fd, SHUT_RDWR);
+        close(server_fd);
+        server_fd = -1;
+    }
+    
+    pthread_join(server_thread, NULL);
+    
+    dlog_print(DLOG_INFO, LOG_TAG, "=== Proxy Server Stopped ===");
+}
+
+// ============================================================================
+// Service Lifecycle Callbacks
+// ============================================================================
+
+bool service_app_create(void* data) {
+    dlog_print(DLOG_INFO, LOG_TAG, "=== Service Creating ===");
+    
+    // Initialize CURL globally
+    CURLcode res = curl_global_init(CURL_GLOBAL_DEFAULT);
+    if (res != CURLE_OK) {
+        dlog_print(DLOG_ERROR, LOG_TAG, "CURL global init failed: %s", curl_easy_strerror(res));
+        return false;
+    }
+    
+    // Start the proxy server
+    if (!start_server()) {
+        curl_global_cleanup();
+        return false;
+    }
+    
+    dlog_print(DLOG_INFO, LOG_TAG, "=== Service Created Successfully ===");
+    return true;
+}
+
+void service_app_terminate(void* data) {
+    dlog_print(DLOG_INFO, LOG_TAG, "=== Service Terminating ===");
+    
+    stop_server();
+    curl_global_cleanup();
+    
+    dlog_print(DLOG_INFO, LOG_TAG, "=== Service Terminated ===");
+}
+
+void service_app_control(app_control_h app_control, void* data) {
+    dlog_print(DLOG_INFO, LOG_TAG, "Service app_control received");
+    // Handle any incoming app control requests here
+}
+
+// ============================================================================
+// Main Entry Point
+// ============================================================================
+
+int main(int argc, char* argv[]) {
+    service_app_lifecycle_callback_s event_callback;
+    memset(&event_callback, 0, sizeof(event_callback));
+    
+    event_callback.create = service_app_create;
+    event_callback.terminate = service_app_terminate;
+    event_callback.app_control = service_app_control;
+    
+    return service_app_main(argc, argv, &event_callback, NULL);
+}

package/app/native_service/tizen-manifest.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<manifest xmlns="http://tizen.org/ns/packages" 
+          api-version="4.0" 
+          package="LIVEFTV001" 
+          version="1.0.0">
+    <profile name="tv"/>
+    
+    <!-- Native Service Application -->
+    <service-application appid="LIVEFTV001.proxyservice" 
+                         exec="proxyservice" 
+                         type="capp" 
+                         nodisplay="true" 
+                         multiple="false" 
+                         auto-restart="true" 
+                         on-boot="false">
+        <label>Proxy Service</label>
+    </service-application>
+    
+    <privileges>
+        <privilege>http://tizen.org/privilege/internet</privilege>
+        <privilege>http://tizen.org/privilege/network.connection</privilege>
+    </privileges>
+</manifest>